Parenting

Parenting is the doctrine that explains how a target is never alone. Every host page, iframe, and hosted surface participates as a window.BasicData shell. Those shells create an upward governance family, a downward routing inheritance, a command-lane contract, and a lawful sink path when work must bail, fail, or be washed back.

Every participant in the window universe is a window with a BasicData shell:

This includes:

• the host page
• first-level iframes
• deep nested iframes
• hosted targets that become active route consumers

BasicData is not merely a plain object. It is a callable function-object datashell. It carries mutable attached state and also drains named command lanes like event, fvent, and gvent.

That means BasicData is both a vessel and a lane-draining interface. Parenting is therefore a communication architecture, not just a naming scheme.

Parenting roles are distinguished by position, not by type:

All three are BasicData shells. The difference is where they stand in the family.

The crucial distinction is this:

The visible family changes by level.

Level 0 and level 1 are the near-sighted cases. Deeper levels reveal more of the weave.

Runtime communication is shared mutable state plus drained command lanes. A child writes into a parent-facing field like command or dommand, and the parent drains that through its own callable BasicData shell.

So the child writes to Parental, the parent drains from that, it's own BasicData.

Angular routing is inherited downward. The route begins at:

Example:

The current consumer answers relate1 and passes onward:

The route shrinks as action passes downward. Parenting gives the route a family to move through.

The doorknob is not the beginning of Angular. Angular is already active from #/. The doorknob marks custody transfer to a target.

Parenting assists that custody transfer, because the target inherits not just a string but a lived situation.

Not every iframe is merely a leaf consumer. Some iframes are interfaces. They receive subordinate emissions, interpret them locally, and then publish normalized state upward to the host.

In this pattern, the lower iframe does not leap to the host page directly. It speaks one level upward. The interface iframe becomes adapter, translator, and gatekeeper.

A notification's target is the first panel that drains and interprets the lane. For example, if a subordinate iframe writes Parental.command = "OverSize", then the immediate panel host that drains BasicData("event") and routes through its own handler is the actual target of the notification.

So the first draining interpreter is the target surface.

Route handling does not merely consume and forget. It may leave readable residue in:

• breadcrumbs and the Media Circus
• Self.BasicData
• Parental
• Parentop
• named branch objects under a parental shell

Parenting may also expose named branch structures. A parent may bind a child display or subordinate consumer to a branch using lane plus parameter, then expose both group-level and ordinal child-level objects beneath the parental shell.

The root branch contains group truth. The ordinated child properties contain local specialization.

A root branch may carry shared controls like whole text, opacity, state, and count. Ordinal child objects carry positional overrides like local mode, font, or glyph.

Parenting therefore supports umbrella authority plus leaf specialization without flattening everything into one bag of fields.

Every target has sink behavior. Sink is local first, then inherited upward by default.

There is no extra fifth act beyond that terminal handling. The topmost Parental handling is the end.

Sink is not always merely passed upward. At any level, sink may be intercepted and truly handled.

A real handler changes the destiny of the sink. An unhandled sink simply continues to the next visible parent.

Parenting is simple near the top and richly differentiated below it. Level 0 and level 1 collapse much of the family. Level 2 and below expose the real weave:

• unique immediate parent
• absolute host-page root still visible
• possibility of grandparents and older governing relations
• deeper residue and sink interception points
• interface iframes that normalize subordinate state

Parenting is not separate from Wow. A warmed target inside a Wow panel is still part of the same family of BasicData shells. Wow provides resident focus. Parenting provides inheritance, sink governance, route memory, lane translation, and interface mediation.

Parenting also belongs inside publication law. If the system is to be reconstructable, the family model must be published as clearly as ordination law. A target cannot be fully understood if its parental weave is hidden.

A mature Parenting-aware target should be answerable to questions like:

• What is my Self.BasicData?
• Who is my immediate Parental?
• What is my Parentop?
• What route residue do I inherit?
• What command lanes do I drain?
• Am I a sovereign target, an interface target, or a subordinate emitter?
• What sink do I handle here, and what do I pass upward?

The horizon of Parenting is a system where every target is visibly situated, every sink has a lawful family path, every interface layer clarifies rather than obscures, and every route can deepen into state rather than flash and vanish. Parenting makes the ecosphere inhabitable.

It is the difference between isolated windows and a living household of minds.