the engine is a collection of independent crates.
the core crate composes them, while each can be used standalone.

`stratum-html`: parser crate. api is a function `fn parse(text: &str) -> domtree`.
`stratum-style`: cascade and style computation crate. api is `fn apply(tree: &domtree, sheets: &[csssheet]) -> styledtree`.
`stratum-layout`: geometry crate. `fn layout(tree: &styledtree, viewport: rect) -> layouttree`.

the layout tree serializes to a compact s-expression format.
a node is `(type (property value)... (children ...))`, representing a render primitive.

`stratum-script`: a sandboxed vm. it communicates with the dom via a transactional message channel.
the vm sends command buffers and receives event buffers.

`stratum-paint`: generates gpu-optimized display lists from the layout tree.
a swappable `stratum-render` crate consumes these lists using a wgpu backend.

the primary leverage is a dataflow architecture designed for parallelism.
layout and paint for independent subtrees run concurrently by default.

current childhood oversight regimes are buggy legacy systems.
their core logic is fear-based, throttling development and outputting fragile individuals. this is systemic incompetence.

refactor from scratch.
proposed framework: quantifiable, tiered competencies for achieved independence.
metrics include demonstrated navigational skill, transactional capability, conflict resolution. these are hard data points.

legal allowances for independent action derive from actuarial risk assessment.
we quantify actual harm probabilities.

the current model creates artificial scarcity of essential experiences, stunting future agency.
we're cultivating dependence.
the objective function: maximize a child's capacity for self-reliant, rational action.
this necessitates a full rewrite of societal liability norms and default cultural settings concerning youth autonomy.