@pibbl/core 0.0.2 → 0.0.3-alpha.109.1

package/dist/lib/layout/participation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/layout/participation.ts"],
+  "sourcesContent": ["import { peekPreNormalizedStyle, type PreparedStyleInput } from '../style/resolve-dispatch.js';\nimport { materializeContainerChildren } from '../element/children.js';\nimport { isKnownLayoutType } from './prepared-root.js';\nimport { getSpecifiedStyle } from '../element/metadata.js';\nimport type { PibblElement } from '../element/types.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport { isSignal, getSignalNode, withSignalDependencyRole } from '../signals/graph.js';\nimport type { PibblComponentRefs, PibblInstance } from '../types.js';\n\nconst contentsTransforms = new WeakSet<Function>();\nexport function registerContentsTransform(type: Function): void { contentsTransforms.add(type); }\nexport function isContentsTransform(type: Function): boolean { return contentsTransforms.has(type); }\n\nexport interface LayoutSuspensionResource { suspendLayout(): void; }\nconst suspensionResources = new WeakMap<PibblComponentRefs<any>, Set<LayoutSuspensionResource>>();\nexport function registerLayoutSuspensionResource(refs: PibblComponentRefs<any>, resource: LayoutSuspensionResource): void {\n  let resources = suspensionResources.get(refs);\n  if (!resources) { resources = new Set(); suspensionResources.set(refs, resources); }\n  resources.add(resource);\n}\nexport function unregisterLayoutSuspensionResource(refs: PibblComponentRefs<any>, resource: LayoutSuspensionResource): void {\n  const resources = suspensionResources.get(refs);\n  resources?.delete(resource);\n  if (resources?.size === 0) suspensionResources.delete(refs);\n}\n\nconst suspendedComponents = new WeakSet<PibblComponentRefs<any>>();\nexport function isLayoutComponentSuspended(refs: PibblComponentRefs<any>): boolean { return !refs.teardowns.closed && suspendedComponents.has(refs); }\nexport function isLayoutInstanceSuspended(owner: PibblInstance): boolean {\n  let current: PibblInstance | undefined = owner;\n  while (current) {\n    if (current.eventParent && isLayoutComponentSuspended(current.eventParent)) return true;\n    current = current.parent ? GLOBAL_STATE.pibblInstances.get(current.parent) : undefined;\n  }\n  return false;\n}\nexport function resumeLayoutComponent(refs: PibblComponentRefs<any>): void { suspendedComponents.delete(refs); }\nfunction participationStyle(element: PibblElement<any>, preparedStyle?: PreparedStyleInput | null): unknown {\n  const prepared = preparedStyle === undefined ? peekPreNormalizedStyle(element) : preparedStyle;\n  if (prepared) return prepared.style;\n  const specified = getSpecifiedStyle(element);\n  if (!isSignal(specified)) return specified;\n  const node = getSignalNode(specified);\n  node.validate?.();\n  const current = node.value;\n  // Ordinary whole-style inputs keep their existing single receiver read.\n  // A participation input acquires its own layout dependency when present.\n  return current && typeof current === 'object' && (current as Record<string, unknown>).layoutParticipation !== undefined\n    ? specified.get() : current;\n}\n\nconst mountedChildren = new WeakMap<PibblComponentRefs<any>, Set<PibblComponentRefs<any>>>();\n\n/** Reads only the structural visibility input; hidden inputs never require measurement. */\nexport function layoutParticipation(element: PibblElement<any>, preparedStyle?: PreparedStyleInput | null): 'normal' | 'hidden' | 'contents' {\n  const style = participationStyle(element, preparedStyle);\n  const input = style && typeof style === 'object' ? (style as Record<string, unknown>).layoutParticipation : undefined;\n  const value = isSignal(input) ? withSignalDependencyRole('layout', () => input.get()) : input;\n  if (value === undefined || value === 'normal') return 'normal';\n  if (value === 'hidden' || value === 'contents') return value;\n  throw new TypeError(`${element.type.name || 'Component'} style.layoutParticipation must be normal, hidden, or contents.`);\n}\n\nexport interface LayoutParticipationSource {\n  readonly element: PibblElement<any>;\n  readonly hidden: boolean;\n  readonly children?: readonly LayoutParticipationSource[];\n}\nconst participationPlans = new WeakMap<readonly PibblElement<any>[], readonly LayoutParticipationSource[]>();\n\n/** Contents may expose only declared structural children, never an opaque component program. */\nexport function contentsChildren(element: PibblElement<any>): readonly PibblElement<any>[] {\n  if (!isContentsTransform(element.type) && !isKnownLayoutType(element.type)) {\n    throw new TypeError(`${element.type.name || 'Component'} contents participation requires a built-in layout or Group with declared structural children.`);\n  }\n  const style = participationStyle(element);\n  if (style && typeof style === 'object') {\n    const values = style as Record<string, unknown>;\n    rejectContentsBoxProperty(values, 'width', element);\n    rejectContentsBoxProperty(values, 'height', element);\n    rejectContentsBoxProperty(values, 'minWidth', element);\n    rejectContentsBoxProperty(values, 'maxWidth', element);\n    rejectContentsBoxProperty(values, 'minHeight', element);\n    rejectContentsBoxProperty(values, 'maxHeight', element);\n    rejectContentsBoxProperty(values, 'boxSizing', element);\n    rejectContentsBoxProperty(values, 'padding', element);\n    rejectContentsBoxProperty(values, 'paddingStart', element);\n    rejectContentsBoxProperty(values, 'paddingEnd', element);\n    rejectContentsBoxProperty(values, 'borderWidth', element);\n    rejectContentsBoxProperty(values, 'borderStartWidth', element);\n    rejectContentsBoxProperty(values, 'borderEndWidth', element);\n    rejectContentsBoxProperty(values, 'overflow', element);\n    rejectContentsBoxProperty(values, 'filter', element);\n    rejectContentsBoxProperty(values, 'position', element);\n    rejectContentsBoxProperty(values, 'left', element);\n    rejectContentsBoxProperty(values, 'right', element);\n    rejectContentsBoxProperty(values, 'top', element);\n    rejectContentsBoxProperty(values, 'bottom', element);\n    rejectContentsBoxProperty(values, 'insetStart', element);\n    rejectContentsBoxProperty(values, 'insetEnd', element);\n    rejectContentsBoxProperty(values, 'margin', element);\n    rejectContentsBoxProperty(values, 'marginTop', element);\n    rejectContentsBoxProperty(values, 'marginRight', element);\n    rejectContentsBoxProperty(values, 'marginBottom', element);\n    rejectContentsBoxProperty(values, 'marginLeft', element);\n    rejectContentsBoxProperty(values, 'marginStart', element);\n    rejectContentsBoxProperty(values, 'marginEnd', element);\n  }\n  const input = (element.props as { readonly children?: import('../element/types.js').PibblNodeInput }).children;\n  return materializeContainerChildren(input, element);\n}\n\nexport function participatingLayoutChildren(source: readonly PibblElement<any>[]): readonly PibblElement<any>[] {\n  let needsPlan = false;\n  for (const element of source) if (layoutParticipation(element) !== 'normal') { needsPlan = true; break; }\n  if (!needsPlan) return source;\n  const leaves: PibblElement<any>[] = [];\n  const visiting = new Set<PibblElement<any>>();\n  const build = (sequence: readonly PibblElement<any>[]): LayoutParticipationSource[] => {\n    const result: LayoutParticipationSource[] = [];\n    for (const element of sequence) {\n      const participation = layoutParticipation(element);\n      if (participation === 'hidden') result.push({ element, hidden: true });\n      else if (participation === 'contents') {\n        if (visiting.has(element)) throw new TypeError('Contents layout descriptors form a cycle.');\n        visiting.add(element);\n        try { result.push({ element, hidden: false, children: build(contentsChildren(element)) }); }\n        finally { visiting.delete(element); }\n      } else { leaves.push(element); result.push({ element, hidden: false }); }\n    }\n    return result;\n  };\n  participationPlans.set(leaves, build(source));\n  return leaves;\n}\n\nexport function layoutParticipationPlan(children: readonly PibblElement<any>[]): readonly LayoutParticipationSource[] | undefined {\n  return participationPlans.get(children);\n}\n\n/** Records mount ownership once; retaining a hidden subtree never scans unrelated mounts. */\nexport function registerLayoutComponentMount(refs: PibblComponentRefs<any>): void {\n  const parent = refs.parent;\n  if (!parent) return;\n  let children = mountedChildren.get(parent);\n  if (!children) { children = new Set(); mountedChildren.set(parent, children); }\n  children.add(refs);\n  const owned = children;\n  refs.teardowns.add(() => { owned.delete(refs); if (!owned.size && mountedChildren.get(parent) === owned) mountedChildren.delete(parent); mountedChildren.delete(refs); });\n}\n\nexport function retainHiddenLayoutDescendants(refs: PibblComponentRefs<any>): void {\n  suspendedComponents.add(refs);\n  refs.renderGeneration = GLOBAL_STATE.currentPibblInstance!.renderGeneration;\n  const resources = suspensionResources.get(refs);\n  if (resources) for (const resource of resources) resource.suspendLayout();\n  const children = mountedChildren.get(refs);\n  if (!children) return;\n  for (const child of children) {\n    if (child.teardowns.closed) continue;\n    GLOBAL_STATE.seenIds!.add(child.id);\n    retainHiddenLayoutDescendants(child);\n  }\n}\n\nfunction rejectContentsBoxProperty(style: Readonly<Record<string, unknown>>, property: string, element: PibblElement<any>): void {\n  const input = style[property];\n  if ((isSignal(input) ? input.get() : input) !== undefined) {\n    throw new TypeError(`${element.type.name} style.${property} requires a box and is incompatible with contents participation.`);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/layout/place-child.js

@@ -24,7 +24,7 @@ function PlacedChild(props, _style, ctx) {
     refs.refs[0] = localBox;
   }
   ctx.translate(props.box.x, props.box.y);
-  const releaseLayout = pushLayoutBox(localBox);
+  const releaseLayout = pushLayoutBox(localBox, { logicalOffset: props.box });
   let releaseClip;
   try {
     const clip = props.clipInChildSpace;

package/dist/lib/layout/place-child.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/layout/place-child.ts"],
-  "sourcesContent": ["import { rectangleSvg } from '../html/portable-clips.js';\nimport { definePrimitive } from '../define-primitive.js';\nimport { createElement } from '../element/create-element.js';\nimport { setPlacementIdentityHint } from '../element/metadata.js';\nimport type { PibblElement } from '../element/types.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport type { InternalIdentityHint, RenderingContext2D } from '../types.js';\nimport { pushClippingPath } from '../util/push-clipping-path.js';\nimport { pushLayoutBox } from './context.js';\nimport { recordLayoutPlacement } from './diagnostics.js';\nimport type { LayoutBox } from './types.js';\n\ninterface PlacedChildProps {\n  element: PibblElement<any>;\n  box: Readonly<LayoutBox>;\n  clipInChildSpace?: Readonly<LayoutBox>;\n  identityHint: InternalIdentityHint;\n}\n\nfunction PlacedChild(\n  props: PlacedChildProps,\n  _style: Readonly<{}>,\n  ctx: RenderingContext2D,\n) {\n  recordLayoutPlacement();\n  assertFiniteBox(props.box, 'placement');\n  if (props.clipInChildSpace) {\n    assertFiniteBox(props.clipInChildSpace, 'placement clip');\n  }\n\n  const refs = GLOBAL_STATE.componentRefs!;\n  let localBox = refs.refs[0] as Readonly<LayoutBox> | undefined;\n  if (\n    !localBox ||\n    localBox.width !== props.box.width ||\n    localBox.height !== props.box.height\n  ) {\n    localBox = Object.freeze({\n      x: 0,\n      y: 0,\n      width: props.box.width,\n      height: props.box.height,\n    });\n    refs.refs[0] = localBox;\n  }\n\n  ctx.translate(props.box.x, props.box.y);\n  const releaseLayout = pushLayoutBox(localBox);\n  let releaseClip: (() => void) | undefined;\n  try {\n    const clip = props.clipInChildSpace;\n    if (clip) {\n      const path = new Path2D();\n      path.rect(clip.x, clip.y, clip.width, clip.height);\n      releaseClip = pushClippingPath(ctx, path, 'nonzero', true, rectangleSvg(clip));\n    }\n  } catch (error) {\n    releaseLayout();\n    throw error;\n  }\n\n  refs.onAfterRender = () => {\n    releaseClip?.();\n    releaseLayout();\n  };\n  return props.element;\n}\n\nconst PlacedChildPrimitive = definePrimitive<PlacedChildProps>(PlacedChild);\n\nexport function placeChild(props: PlacedChildProps): PibblElement<any> {\n  const element = createElement(PlacedChildPrimitive, props);\n  setPlacementIdentityHint(element, props.identityHint);\n  return element;\n}\n\nexport function createPlacementIdentityHint(\n  element: PibblElement<any>,\n  occurrence: number,\n): InternalIdentityHint {\n  if (!Number.isInteger(occurrence) || occurrence < 0) {\n    throw new Error('Placement identity occurrence must be a nonnegative integer');\n  }\n  return { type: element.type, key: element.key, occurrence };\n}\n\nfunction assertFiniteBox(box: Readonly<LayoutBox>, label: string): void {\n  for (const [property, value] of Object.entries(box)) {\n    if (!Number.isFinite(value)) {\n      throw new Error(`${label} ${property} must be finite, received ${value}`);\n    }\n  }\n  if (box.width < 0 || box.height < 0) {\n    throw new Error(`${label} dimensions must be nonnegative`);\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,SAAS,gCAAgC;AAEzC,SAAS,oBAAoB;AAE7B,SAAS,wBAAwB;AACjC,SAAS,qBAAqB;AAC9B,SAAS,6BAA6B;AAUtC,SAAS,YACP,OACA,QACA,KACA;AACA,wBAAsB;AACtB,kBAAgB,MAAM,KAAK,WAAW;AACtC,MAAI,MAAM,kBAAkB;AAC1B,oBAAgB,MAAM,kBAAkB,gBAAgB;AAAA,EAC1D;AAEA,QAAM,OAAO,aAAa;AAC1B,MAAI,WAAW,KAAK,KAAK,CAAC;AAC1B,MACE,CAAC,YACD,SAAS,UAAU,MAAM,IAAI,SAC7B,SAAS,WAAW,MAAM,IAAI,QAC9B;AACA,eAAW,OAAO,OAAO;AAAA,MACvB,GAAG;AAAA,MACH,GAAG;AAAA,MACH,OAAO,MAAM,IAAI;AAAA,MACjB,QAAQ,MAAM,IAAI;AAAA,IACpB,CAAC;AACD,SAAK,KAAK,CAAC,IAAI;AAAA,EACjB;AAEA,MAAI,UAAU,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;AACtC,QAAM,gBAAgB,cAAc,QAAQ;AAC5C,MAAI;AACJ,MAAI;AACF,UAAM,OAAO,MAAM;AACnB,QAAI,MAAM;AACR,YAAM,OAAO,IAAI,OAAO;AACxB,WAAK,KAAK,KAAK,GAAG,KAAK,GAAG,KAAK,OAAO,KAAK,MAAM;AACjD,oBAAc,iBAAiB,KAAK,MAAM,WAAW,MAAM,aAAa,IAAI,CAAC;AAAA,IAC/E;AAAA,EACF,SAAS,OAAO;AACd,kBAAc;AACd,UAAM;AAAA,EACR;AAEA,OAAK,gBAAgB,MAAM;AACzB,kBAAc;AACd,kBAAc;AAAA,EAChB;AACA,SAAO,MAAM;AACf;AAEA,MAAM,uBAAuB,gBAAkC,WAAW;AAEnE,SAAS,WAAW,OAA4C;AACrE,QAAM,UAAU,cAAc,sBAAsB,KAAK;AACzD,2BAAyB,SAAS,MAAM,YAAY;AACpD,SAAO;AACT;AAEO,SAAS,4BACd,SACA,YACsB;AACtB,MAAI,CAAC,OAAO,UAAU,UAAU,KAAK,aAAa,GAAG;AACnD,UAAM,IAAI,MAAM,6DAA6D;AAAA,EAC/E;AACA,SAAO,EAAE,MAAM,QAAQ,MAAM,KAAK,QAAQ,KAAK,WAAW;AAC5D;AAEA,SAAS,gBAAgB,KAA0B,OAAqB;AACtE,aAAW,CAAC,UAAU,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AACnD,QAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,YAAM,IAAI,MAAM,GAAG,KAAK,IAAI,QAAQ,6BAA6B,KAAK,EAAE;AAAA,IAC1E;AAAA,EACF;AACA,MAAI,IAAI,QAAQ,KAAK,IAAI,SAAS,GAAG;AACnC,UAAM,IAAI,MAAM,GAAG,KAAK,iCAAiC;AAAA,EAC3D;AACF;",
+  "sourcesContent": ["import { rectangleSvg } from '../html/portable-clips.js';\nimport { definePrimitive } from '../define-primitive.js';\nimport { createElement } from '../element/create-element.js';\nimport { setPlacementIdentityHint } from '../element/metadata.js';\nimport type { PibblElement } from '../element/types.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport type { InternalIdentityHint, RenderingContext2D } from '../types.js';\nimport { pushClippingPath } from '../util/push-clipping-path.js';\nimport { pushLayoutBox } from './context.js';\nimport { recordLayoutPlacement } from './diagnostics.js';\nimport type { LayoutBox } from './types.js';\n\ninterface PlacedChildProps {\n  element: PibblElement<any>;\n  box: Readonly<LayoutBox>;\n  clipInChildSpace?: Readonly<LayoutBox>;\n  identityHint: InternalIdentityHint;\n}\n\nfunction PlacedChild(\n  props: PlacedChildProps,\n  _style: Readonly<{}>,\n  ctx: RenderingContext2D,\n) {\n  recordLayoutPlacement();\n  assertFiniteBox(props.box, 'placement');\n  if (props.clipInChildSpace) {\n    assertFiniteBox(props.clipInChildSpace, 'placement clip');\n  }\n\n  const refs = GLOBAL_STATE.componentRefs!;\n  let localBox = refs.refs[0] as Readonly<LayoutBox> | undefined;\n  if (\n    !localBox ||\n    localBox.width !== props.box.width ||\n    localBox.height !== props.box.height\n  ) {\n    localBox = Object.freeze({\n      x: 0,\n      y: 0,\n      width: props.box.width,\n      height: props.box.height,\n    });\n    refs.refs[0] = localBox;\n  }\n\n  ctx.translate(props.box.x, props.box.y);\n  const releaseLayout = pushLayoutBox(localBox, { logicalOffset: props.box });\n  let releaseClip: (() => void) | undefined;\n  try {\n    const clip = props.clipInChildSpace;\n    if (clip) {\n      const path = new Path2D();\n      path.rect(clip.x, clip.y, clip.width, clip.height);\n      releaseClip = pushClippingPath(ctx, path, 'nonzero', true, rectangleSvg(clip));\n    }\n  } catch (error) {\n    releaseLayout();\n    throw error;\n  }\n\n  refs.onAfterRender = () => {\n    releaseClip?.();\n    releaseLayout();\n  };\n  return props.element;\n}\n\nconst PlacedChildPrimitive = definePrimitive<PlacedChildProps>(PlacedChild);\n\nexport function placeChild(props: PlacedChildProps): PibblElement<any> {\n  const element = createElement(PlacedChildPrimitive, props);\n  setPlacementIdentityHint(element, props.identityHint);\n  return element;\n}\n\nexport function createPlacementIdentityHint(\n  element: PibblElement<any>,\n  occurrence: number,\n): InternalIdentityHint {\n  if (!Number.isInteger(occurrence) || occurrence < 0) {\n    throw new Error('Placement identity occurrence must be a nonnegative integer');\n  }\n  return { type: element.type, key: element.key, occurrence };\n}\n\nfunction assertFiniteBox(box: Readonly<LayoutBox>, label: string): void {\n  for (const [property, value] of Object.entries(box)) {\n    if (!Number.isFinite(value)) {\n      throw new Error(`${label} ${property} must be finite, received ${value}`);\n    }\n  }\n  if (box.width < 0 || box.height < 0) {\n    throw new Error(`${label} dimensions must be nonnegative`);\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,SAAS,gCAAgC;AAEzC,SAAS,oBAAoB;AAE7B,SAAS,wBAAwB;AACjC,SAAS,qBAAqB;AAC9B,SAAS,6BAA6B;AAUtC,SAAS,YACP,OACA,QACA,KACA;AACA,wBAAsB;AACtB,kBAAgB,MAAM,KAAK,WAAW;AACtC,MAAI,MAAM,kBAAkB;AAC1B,oBAAgB,MAAM,kBAAkB,gBAAgB;AAAA,EAC1D;AAEA,QAAM,OAAO,aAAa;AAC1B,MAAI,WAAW,KAAK,KAAK,CAAC;AAC1B,MACE,CAAC,YACD,SAAS,UAAU,MAAM,IAAI,SAC7B,SAAS,WAAW,MAAM,IAAI,QAC9B;AACA,eAAW,OAAO,OAAO;AAAA,MACvB,GAAG;AAAA,MACH,GAAG;AAAA,MACH,OAAO,MAAM,IAAI;AAAA,MACjB,QAAQ,MAAM,IAAI;AAAA,IACpB,CAAC;AACD,SAAK,KAAK,CAAC,IAAI;AAAA,EACjB;AAEA,MAAI,UAAU,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;AACtC,QAAM,gBAAgB,cAAc,UAAU,EAAE,eAAe,MAAM,IAAI,CAAC;AAC1E,MAAI;AACJ,MAAI;AACF,UAAM,OAAO,MAAM;AACnB,QAAI,MAAM;AACR,YAAM,OAAO,IAAI,OAAO;AACxB,WAAK,KAAK,KAAK,GAAG,KAAK,GAAG,KAAK,OAAO,KAAK,MAAM;AACjD,oBAAc,iBAAiB,KAAK,MAAM,WAAW,MAAM,aAAa,IAAI,CAAC;AAAA,IAC/E;AAAA,EACF,SAAS,OAAO;AACd,kBAAc;AACd,UAAM;AAAA,EACR;AAEA,OAAK,gBAAgB,MAAM;AACzB,kBAAc;AACd,kBAAc;AAAA,EAChB;AACA,SAAO,MAAM;AACf;AAEA,MAAM,uBAAuB,gBAAkC,WAAW;AAEnE,SAAS,WAAW,OAA4C;AACrE,QAAM,UAAU,cAAc,sBAAsB,KAAK;AACzD,2BAAyB,SAAS,MAAM,YAAY;AACpD,SAAO;AACT;AAEO,SAAS,4BACd,SACA,YACsB;AACtB,MAAI,CAAC,OAAO,UAAU,UAAU,KAAK,aAAa,GAAG;AACnD,UAAM,IAAI,MAAM,6DAA6D;AAAA,EAC/E;AACA,SAAO,EAAE,MAAM,QAAQ,MAAM,KAAK,QAAQ,KAAK,WAAW;AAC5D;AAEA,SAAS,gBAAgB,KAA0B,OAAqB;AACtE,aAAW,CAAC,UAAU,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AACnD,QAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,YAAM,IAAI,MAAM,GAAG,KAAK,IAAI,QAAQ,6BAA6B,KAAK,EAAE;AAAA,IAC1E;AAAA,EACF;AACA,MAAI,IAAI,QAAQ,KAAK,IAAI,SAAS,GAAG;AACnC,UAAM,IAAI,MAAM,GAAG,KAAK,iCAAiC;AAAA,EAC3D;AACF;",
   "names": []
 }

package/dist/lib/layout/positioning-diagnostics.d.ts

@@ -1,3 +1,3 @@
 import type { PibblElement } from '../element/types.js';
 import type { SystemStyle } from '../types.js';
-export declare function assertSupportedChildPosition(layout: string, child: PibblElement<any>, style: Readonly<SystemStyle>): void;
+export declare function assertSupportedChildPosition(layout: string, child: PibblElement<any>, style: Readonly<SystemStyle>, supportsExplicitPosition?: boolean, rejectsLegacyOffsets?: boolean): void;

package/dist/lib/layout/positioning-diagnostics.js

@@ -1,8 +1,19 @@
 import { isDevelopment } from "../development.js";
 import { getElementSource } from "../element/metadata.js";
-function assertSupportedChildPosition(layout, child, style) {
-  if (!isDevelopment) return;
+function assertSupportedChildPosition(layout, child, style, supportsExplicitPosition = false, rejectsLegacyOffsets = true) {
   const values = style;
+  const position = values.position;
+  if ((values.insetStart !== void 0 || values.insetEnd !== void 0) && (!supportsExplicitPosition || position !== "absolute")) {
+    throw new Error(`PIBBL_LAYOUT_UNSUPPORTED_POSITION: logical insets require a supported direct absolute Flex child; ${child.type.name || "Anonymous"} inside ${layout} cannot apply them.`);
+  }
+  if (position !== void 0 && (!supportsExplicitPosition || position !== "static" && position !== "relative" && position !== "absolute")) {
+    throw new Error(`PIBBL_LAYOUT_UNSUPPORTED_POSITION: ${child.type.name || "Anonymous"} inside ${layout} declares position: ${String(position)}. ${layout} does not support this placement mode.`);
+  }
+  const hasRightOrBottom = values.right !== void 0 || values.bottom !== void 0;
+  if (position === void 0 && hasRightOrBottom) {
+    throw new Error(`PIBBL_LAYOUT_IGNORED_POSITION: ${child.type.name || "Anonymous"} inside ${layout} declares right/bottom without an explicit position. ${layout} cannot apply these insets.`);
+  }
+  if (!isDevelopment || position !== void 0 || !rejectsLegacyOffsets) return;
   const fields = ["left", "top"].filter((key) => Object.prototype.hasOwnProperty.call(values, key) && values[key] !== void 0);
   if (fields.length === 0) return;
   const source = getElementSource(child);

package/dist/lib/layout/positioning-diagnostics.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/layout/positioning-diagnostics.ts"],
-  "sourcesContent": ["import { isDevelopment } from '../development.js';\nimport { getElementSource } from '../element/metadata.js';\nimport type { PibblElement } from '../element/types.js';\nimport type { SystemStyle } from '../types.js';\n\nexport function assertSupportedChildPosition(layout: string, child: PibblElement<any>, style: Readonly<SystemStyle>): void {\n  if (!isDevelopment) return;\n  const values = style as Readonly<Record<string, unknown>>;\n  const fields = (['left', 'top'] as const).filter(key => Object.prototype.hasOwnProperty.call(values, key) && values[key] !== undefined);\n  if (fields.length === 0) return;\n  const source = getElementSource(child);\n  const location = source ? ` Source: ${source.fileName}:${source.lineNumber}` : '';\n  throw new Error(`PIBBL_LAYOUT_IGNORED_POSITION: ${child.type.name || 'Anonymous'} inside ${layout} declares ${fields.map(key => `${key}: ${String(values[key])}`).join(', ')}. ${layout} controls this child's position; these fields have no effect. Use ${layout} alignment/gap or an Absolute region for positioned content.${location}`);\n}\n"],
-  "mappings": "AAAA,SAAS,qBAAqB;AAC9B,SAAS,wBAAwB;AAI1B,SAAS,6BAA6B,QAAgB,OAA0B,OAAoC;AACzH,MAAI,CAAC,cAAe;AACpB,QAAM,SAAS;AACf,QAAM,SAAU,CAAC,QAAQ,KAAK,EAAY,OAAO,SAAO,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,KAAK,OAAO,GAAG,MAAM,MAAS;AACtI,MAAI,OAAO,WAAW,EAAG;AACzB,QAAM,SAAS,iBAAiB,KAAK;AACrC,QAAM,WAAW,SAAS,YAAY,OAAO,QAAQ,IAAI,OAAO,UAAU,KAAK;AAC/E,QAAM,IAAI,MAAM,kCAAkC,MAAM,KAAK,QAAQ,WAAW,WAAW,MAAM,aAAa,OAAO,IAAI,SAAO,GAAG,GAAG,KAAK,OAAO,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,KAAK,MAAM,qEAAqE,MAAM,+DAA+D,QAAQ,EAAE;AAC7U;",
+  "sourcesContent": ["import { isDevelopment } from '../development.js';\nimport { getElementSource } from '../element/metadata.js';\nimport type { PibblElement } from '../element/types.js';\nimport type { SystemStyle } from '../types.js';\n\nexport function assertSupportedChildPosition(layout: string, child: PibblElement<any>, style: Readonly<SystemStyle>, supportsExplicitPosition = false, rejectsLegacyOffsets = true): void {\n  const values = style as Readonly<Record<string, unknown>>;\n  const position = values.position;\n  if ((values.insetStart !== undefined || values.insetEnd !== undefined) &&\n      (!supportsExplicitPosition || position !== 'absolute')) {\n    throw new Error(`PIBBL_LAYOUT_UNSUPPORTED_POSITION: logical insets require a supported direct absolute Flex child; ${child.type.name || 'Anonymous'} inside ${layout} cannot apply them.`);\n  }\n  if (position !== undefined && (!supportsExplicitPosition || (position !== 'static' && position !== 'relative' && position !== 'absolute'))) {\n    throw new Error(`PIBBL_LAYOUT_UNSUPPORTED_POSITION: ${child.type.name || 'Anonymous'} inside ${layout} declares position: ${String(position)}. ${layout} does not support this placement mode.`);\n  }\n  const hasRightOrBottom = values.right !== undefined || values.bottom !== undefined;\n  if (position === undefined && hasRightOrBottom) {\n    throw new Error(`PIBBL_LAYOUT_IGNORED_POSITION: ${child.type.name || 'Anonymous'} inside ${layout} declares right/bottom without an explicit position. ${layout} cannot apply these insets.`);\n  }\n  if (!isDevelopment || position !== undefined || !rejectsLegacyOffsets) return;\n  const fields = (['left', 'top'] as const).filter(key => Object.prototype.hasOwnProperty.call(values, key) && values[key] !== undefined);\n  if (fields.length === 0) return;\n  const source = getElementSource(child);\n  const location = source ? ` Source: ${source.fileName}:${source.lineNumber}` : '';\n  throw new Error(`PIBBL_LAYOUT_IGNORED_POSITION: ${child.type.name || 'Anonymous'} inside ${layout} declares ${fields.map(key => `${key}: ${String(values[key])}`).join(', ')}. ${layout} controls this child's position; these fields have no effect. Use ${layout} alignment/gap or an Absolute region for positioned content.${location}`);\n}\n"],
+  "mappings": "AAAA,SAAS,qBAAqB;AAC9B,SAAS,wBAAwB;AAI1B,SAAS,6BAA6B,QAAgB,OAA0B,OAA8B,2BAA2B,OAAO,uBAAuB,MAAY;AACxL,QAAM,SAAS;AACf,QAAM,WAAW,OAAO;AACxB,OAAK,OAAO,eAAe,UAAa,OAAO,aAAa,YACvD,CAAC,4BAA4B,aAAa,aAAa;AAC1D,UAAM,IAAI,MAAM,qGAAqG,MAAM,KAAK,QAAQ,WAAW,WAAW,MAAM,qBAAqB;AAAA,EAC3L;AACA,MAAI,aAAa,WAAc,CAAC,4BAA6B,aAAa,YAAY,aAAa,cAAc,aAAa,aAAc;AAC1I,UAAM,IAAI,MAAM,sCAAsC,MAAM,KAAK,QAAQ,WAAW,WAAW,MAAM,uBAAuB,OAAO,QAAQ,CAAC,KAAK,MAAM,wCAAwC;AAAA,EACjM;AACA,QAAM,mBAAmB,OAAO,UAAU,UAAa,OAAO,WAAW;AACzE,MAAI,aAAa,UAAa,kBAAkB;AAC9C,UAAM,IAAI,MAAM,kCAAkC,MAAM,KAAK,QAAQ,WAAW,WAAW,MAAM,wDAAwD,MAAM,6BAA6B;AAAA,EAC9L;AACA,MAAI,CAAC,iBAAiB,aAAa,UAAa,CAAC,qBAAsB;AACvE,QAAM,SAAU,CAAC,QAAQ,KAAK,EAAY,OAAO,SAAO,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,KAAK,OAAO,GAAG,MAAM,MAAS;AACtI,MAAI,OAAO,WAAW,EAAG;AACzB,QAAM,SAAS,iBAAiB,KAAK;AACrC,QAAM,WAAW,SAAS,YAAY,OAAO,QAAQ,IAAI,OAAO,UAAU,KAAK;AAC/E,QAAM,IAAI,MAAM,kCAAkC,MAAM,KAAK,QAAQ,WAAW,WAAW,MAAM,aAAa,OAAO,IAAI,SAAO,GAAG,GAAG,KAAK,OAAO,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,KAAK,MAAM,qEAAqE,MAAM,+DAA+D,QAAQ,EAAE;AAC7U;",
   "names": []
 }

package/dist/lib/layout/prepared-root.d.ts

@@ -0,0 +1,121 @@
+import type { BoxStyle } from '../style/types.js';
+import { LayoutRegion } from './wasm/region.js';
+import type { PibblInstance } from '../types.js';
+import type { PibblElement } from '../element/types.js';
+import type { SystemStyle } from '../types.js';
+import type { ResponsiveStylePreparation } from '../style/responsive.js';
+import type { LayoutBox } from './types.js';
+import { type LayoutTopologySlot } from './topology.js';
+export { snapshotLayoutTopology } from './topology.js';
+type PreparedStyle = Readonly<SystemStyle> | ResponsiveStylePreparation<Readonly<SystemStyle>>;
+export interface KnownLayoutPreflightOptions {
+    readonly deferStaticContainingDescendants?: boolean;
+}
+type Preflight = (element: PibblElement<any>, style: Readonly<SystemStyle>, content: Readonly<LayoutBox>, receiver: object, slot: PreparedLayoutSlot, parentMainAxis?: 'row' | 'column', options?: KnownLayoutPreflightOptions) => void;
+export declare function isKnownLayoutType(type: Function): boolean;
+/** Only the current transaction's settled preparation may be attached to a replay. */
+export declare function currentPreparedReceiverSlot(receiver: object | undefined): PreparedLayoutSlot | undefined;
+/** Registers only known declarative input preparation, never component evaluation. */
+export declare function registerKnownLayoutPreflight(type: Function, preflight: Preflight): void;
+export declare function preflightKnownLayout(element: PibblElement<any>, style: Readonly<SystemStyle>, content: Readonly<LayoutBox>, receiver?: object, occurrence?: number, parentSlot?: PreparedLayoutSlot, parentMainAxis?: 'row' | 'column', options?: KnownLayoutPreflightOptions): PreparedLayoutSlot | undefined;
+export declare function attachPreparedLayoutSlot(element: PibblElement<any>, slot?: PreparedLayoutSlot): void;
+export interface PreparedPlanPending {
+    readonly kind: 'static-flex-containing-origin';
+    count: number;
+}
+export interface PreparedLayoutPlan {
+    readonly region?: LayoutRegion;
+    readonly content: Readonly<LayoutBox>;
+    readonly children: readonly PibblElement<any>[];
+    readonly placements: {
+        box: LayoutBox;
+        element: PibblElement<any>;
+    }[];
+    /** A staged plan cannot transfer ownership while a late containing origin is unresolved. */
+    pending?: PreparedPlanPending;
+}
+export interface PreparedFlexLayoutPlan extends PreparedLayoutPlan {
+    readonly region: LayoutRegion;
+    readonly cached: boolean;
+    readonly revision: number;
+    readonly placements: {
+        box: LayoutBox;
+        layoutY: number;
+        usedWidth: number;
+        usedHeight: number;
+        element: PibblElement<any>;
+    }[];
+}
+export declare class PreparedLayoutSlot implements LayoutTopologySlot {
+    readonly topologyOwner: PibblInstance;
+    region: LayoutRegion | undefined;
+    private boundaryOwner;
+    claimBoundary(): void;
+    readonly children: Map<Function, Map<string, PreparedLayoutSlot>>;
+    private disposeChildren;
+    private readonly rootType;
+    private readonly rootKey;
+    private readonly release;
+    constructor(topologyOwner: PibblInstance, options: {
+        rootType: Function;
+        rootKey?: string;
+        release: () => void;
+    });
+    matchesRoot(root: PibblElement<any>): boolean;
+    acquire(): LayoutRegion;
+    dispose(): void;
+    claim(region: LayoutRegion): void;
+}
+export declare function stagePreparedLayoutPlan(slot: PreparedLayoutSlot, plan: PreparedLayoutPlan): void;
+export declare function claimPreparedLayoutPlan(element: PibblElement<any>, content: Readonly<LayoutBox>): PreparedLayoutPlan | undefined;
+export declare function claimPreparedFlexPlan(element: PibblElement<any>, content: Readonly<LayoutBox>): PreparedFlexLayoutPlan | undefined;
+/** @internal Reads a current staged plan without transferring its region. */
+export declare function peekPreparedLayoutPlan(slot: PreparedLayoutSlot, content: Readonly<LayoutBox>, direction?: 'ltr' | 'rtl'): PreparedLayoutPlan | undefined;
+/** @internal Reads a current staged Flex plan without transferring its region. */
+export declare function peekPreparedFlexPlan(slot: PreparedLayoutSlot, content: Readonly<LayoutBox>, direction?: 'ltr' | 'rtl'): PreparedFlexLayoutPlan | undefined;
+export declare function stagePreparedChildStyle(child: PibblElement<any>, receiver: object, content: Readonly<LayoutBox>, prepared: PreparedStyle): void;
+export declare function takePreparedChildStyle(child: PibblElement<any>, receiver?: object, content?: Readonly<LayoutBox>): PreparedStyle | undefined;
+export declare function hasPreparedChildStyles(): boolean;
+export declare function stagePreparedBoundaryChildren(slot: PreparedLayoutSlot, children: readonly PibblElement<any>[]): void;
+export declare function takePreparedBoundaryChildren(element: PibblElement<any>): readonly PibblElement<any>[] | undefined;
+/**
+ * Whether a staged raster boundary contains a settled numeric layout plan.
+ * Opaque descendants deliberately do not count: they retain the scheduler's
+ * child-first ownership path until they are themselves prepared.
+ */
+export declare function preparedBoundaryNeedsAllocationParent(element: PibblElement<any>): boolean;
+/** A clean Layer keeps the mounted descendants that already own these plans. */
+export declare function retainPreparedBoundarySubtree(element: PibblElement<any>): void;
+/** Carries a settled placement into known preparation without a second placement pass. */
+export declare function preparePlacedKnownLayout(element: PibblElement<any>, occurrence: number, parentSlot?: PreparedLayoutSlot): void;
+/** Recursively admits known placed roots without evaluating opaque components. */
+export declare function prepareKnownLayoutDescendants(plan: Pick<PreparedLayoutPlan, 'children' | 'placements'>, parentSlot: PreparedLayoutSlot): void;
+/**
+ * A native intrinsic-main query has already chosen final numeric child bounds.
+ * It is scoped to this render transaction and consumed once by the matching
+ * normal Flex root; no persistent layout graph or receiver receipt is retained.
+ */
+export interface PreparedIntrinsicMainStage {
+    /** The flattened source descriptors measured by this stage. */
+    readonly elements: readonly PibblElement<any>[];
+    readonly axis: 'row' | 'column';
+    readonly style: Readonly<BoxStyle>;
+    readonly rootMin?: number;
+    readonly rootMax?: number;
+    readonly contentMain: number;
+    /** Normal numeric-owner phases already include the final recursive bounds. */
+    readonly normalOwner?: boolean;
+    /** Native phase residual, distinct from final geometric remainder. */
+    readonly autoMarginFreeMain?: number;
+    readonly revision: number;
+    readonly items: readonly Readonly<{
+        sourceIndex: number;
+        target: number;
+        min: number;
+        max: number;
+        measured?: boolean;
+    }>[];
+}
+export declare function stagePreparedIntrinsicMain(receiver: object | undefined, stage: PreparedIntrinsicMainStage): void;
+export declare function peekPreparedIntrinsicMain(receiver: object | undefined, elements: readonly PibblElement<any>[], axis: 'row' | 'column', contentMain: number, revision: number): PreparedIntrinsicMainStage | undefined;
+export declare function takePreparedIntrinsicMain(receiver: object | undefined, elements: readonly PibblElement<any>[], axis: 'row' | 'column', contentMain: number, revision: number): PreparedIntrinsicMainStage | undefined;

package/dist/lib/layout/prepared-root.js

@@ -0,0 +1,360 @@
+import { disposeAllocationCheckpoint, adoptAllocationCheckpointOwner } from "./allocation-checkpoint-owner.js";
+import { getLayoutDirection } from "./context.js";
+import { peekPreNormalizedStyle } from "../style/resolve-dispatch.js";
+import { isLayoutComponent, prepareLayoutComponent } from "./define-layout-component.js";
+import { getElementMetadata, setElementMetadata, getPrimitiveReceiverToken } from "../element/metadata.js";
+import { LayoutRegion, adoptMountedLayoutRegion } from "./wasm/region.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import { releaseLayoutTopology, stageLayoutTopology } from "./topology.js";
+import { snapshotLayoutTopology } from "./topology.js";
+const preflights = /* @__PURE__ */ new WeakMap();
+function isKnownLayoutType(type) {
+  return preflights.has(type);
+}
+const currentReceiverSlots = /* @__PURE__ */ new WeakMap();
+function currentPreparedReceiverSlot(receiver) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  return transaction && receiver ? currentReceiverSlots.get(transaction)?.get(receiver) : void 0;
+}
+const snapshots = /* @__PURE__ */ new WeakMap();
+function registerKnownLayoutPreflight(type, preflight) {
+  preflights.set(type, preflight);
+}
+function preflightKnownLayout(element, style, content, receiver, occurrence = 0, parentSlot, parentMainAxis, options) {
+  const parent = GLOBAL_STATE.componentRefs, owner = GLOBAL_STATE.currentPibblInstance;
+  if (!receiver || !parent || !owner || !GLOBAL_STATE.renderTransaction) return;
+  const root = isLayoutComponent(element.type) ? prepareLayoutComponent(element, { receiverToken: receiver }) : element;
+  const preflight = preflights.get(root.type);
+  if (!preflight) return;
+  const rootReceiver = root === element ? receiver : getPrimitiveReceiverToken(root);
+  if (!rootReceiver) throw new Error("A prepared layout description requires its own root receiver.");
+  const transaction = GLOBAL_STATE.renderTransaction;
+  let visiting = activeDescriptions.get(transaction);
+  if (!visiting) {
+    visiting = /* @__PURE__ */ new Set();
+    activeDescriptions.set(transaction, visiting);
+  }
+  const source = getElementMetadata(element)?.layoutDescriptionSource ?? element;
+  if (visiting.has(source)) throw new Error("Known layout descriptions form a cycle.");
+  visiting.add(source);
+  try {
+    let types = parentSlot?.children ?? slots.get(parent);
+    if (!types) {
+      types = /* @__PURE__ */ new Map();
+      slots.set(parent, types);
+      const owned = types;
+      parent.teardowns.add(() => {
+        for (const entries2 of owned.values()) for (const slot2 of entries2.values()) slot2.dispose();
+        owned.clear();
+        slots.delete(parent);
+      });
+    }
+    let entries = types.get(element.type);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      types.set(element.type, entries);
+    }
+    const key = element.key === void 0 ? `occurrence:${occurrence}` : `key:${element.key}`;
+    let slot = entries.get(key);
+    if (slot && !slot.matchesRoot(root)) {
+      slot.dispose();
+      slot = void 0;
+      types.set(element.type, entries);
+    }
+    if (!slot) {
+      const ownedEntries = entries, ownedTypes = types;
+      const created = new PreparedLayoutSlot(owner.interactionRoot ?? owner, {
+        rootType: root.type,
+        rootKey: root.key,
+        release: () => {
+          if (ownedEntries.get(key) !== created) return;
+          ownedEntries.delete(key);
+          if (!ownedEntries.size) ownedTypes.delete(element.type);
+        }
+      });
+      slot = created;
+      entries.set(key, slot);
+    }
+    stageLayoutTopology(transaction, slot, parentSlot);
+    preflight(root, style, content, rootReceiver, slot, parentMainAxis, options);
+    let receivers = currentReceiverSlots.get(transaction);
+    if (!receivers) {
+      receivers = /* @__PURE__ */ new WeakMap();
+      currentReceiverSlots.set(transaction, receivers);
+    }
+    receivers.set(receiver, slot);
+    receivers.set(rootReceiver, slot);
+    return slot;
+  } finally {
+    visiting.delete(source);
+  }
+}
+function attachPreparedLayoutSlot(element, slot) {
+  if (slot) setElementMetadata(element, { ...getElementMetadata(element), preparedLayoutSlot: slot });
+}
+class PreparedLayoutSlot {
+  constructor(topologyOwner, options) {
+    this.topologyOwner = topologyOwner;
+    this.rootType = options.rootType;
+    this.rootKey = options.rootKey;
+    this.release = options.release;
+  }
+  topologyOwner;
+  region;
+  boundaryOwner;
+  claimBoundary() {
+    const refs = GLOBAL_STATE.componentRefs;
+    if (this.boundaryOwner === refs) return;
+    this.boundaryOwner = refs;
+    adoptAllocationCheckpointOwner(this);
+    refs.teardowns.add(() => {
+      if (this.boundaryOwner === refs) this.dispose();
+    });
+  }
+  children = /* @__PURE__ */ new Map();
+  disposeChildren() {
+    for (const entries of this.children.values()) for (const child of entries.values()) child.dispose();
+    this.children.clear();
+  }
+  rootType;
+  rootKey;
+  release;
+  matchesRoot(root) {
+    return this.rootType === root.type && this.rootKey === root.key;
+  }
+  acquire() {
+    return this.region ??= new LayoutRegion(this.topologyOwner);
+  }
+  dispose() {
+    disposeAllocationCheckpoint(this);
+    const region = this.region;
+    this.region = void 0;
+    this.boundaryOwner = void 0;
+    try {
+      this.disposeChildren();
+      region?.dispose();
+    } finally {
+      releaseLayoutTopology(this);
+      this.release();
+    }
+  }
+  claim(region) {
+    if (this.region !== region) throw new Error("Prepared layout region is stale.");
+    adoptMountedLayoutRegion(region, () => {
+      if (this.region === region) {
+        this.region = void 0;
+        this.disposeChildren();
+        releaseLayoutTopology(this);
+        this.release();
+      }
+    });
+  }
+}
+const activeDescriptions = /* @__PURE__ */ new WeakMap();
+const slots = /* @__PURE__ */ new WeakMap();
+const plans = /* @__PURE__ */ new WeakMap();
+function stagePreparedLayoutPlan(slot, plan) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  let pending = plans.get(transaction);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    plans.set(transaction, pending);
+    const owned = pending;
+    transaction.onFinish(() => {
+      for (const [slot2, entry] of owned) if (!entry.claimed) slot2.dispose();
+      owned.clear();
+      plans.delete(transaction);
+    });
+  }
+  if (pending.has(slot)) throw new Error("Duplicate known layout occurrence during preparation.");
+  pending.set(slot, { plan, direction: getLayoutDirection(), claimed: false });
+}
+function claimPreparedLayoutPlan(element, content) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const slot = getElementMetadata(element)?.preparedLayoutSlot;
+  if (!transaction || !slot) return;
+  const entry = plans.get(transaction)?.get(slot);
+  if (!entry || entry.claimed || entry.direction !== getLayoutDirection() || entry.plan.content.width !== content.width || entry.plan.content.height !== content.height) throw new Error("Prepared layout plan does not match its allocation.");
+  if (entry.plan.pending?.count) throw new Error("Prepared static Flex descendants did not receive a settled containing origin.");
+  if (entry.plan.region) slot.claim(entry.plan.region);
+  else slot.claimBoundary();
+  entry.claimed = true;
+  return entry.plan;
+}
+function claimPreparedFlexPlan(element, content) {
+  const plan = claimPreparedLayoutPlan(element, content);
+  if (!plan) return;
+  if (!plan.region || !("cached" in plan) || typeof plan.cached !== "boolean" || !("revision" in plan) || typeof plan.revision !== "number") throw new Error("Prepared Flex plan is incompatible with this boundary.");
+  return plan;
+}
+function peekPreparedLayoutPlan(slot, content, direction = getLayoutDirection()) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const entry = transaction ? plans.get(transaction)?.get(slot) : void 0;
+  if (!entry || entry.claimed || entry.direction !== direction || entry.plan.content.width !== content.width || entry.plan.content.height !== content.height) return;
+  return entry.plan;
+}
+function peekPreparedFlexPlan(slot, content, direction = getLayoutDirection()) {
+  const plan = peekPreparedLayoutPlan(slot, content, direction);
+  if (!plan) return;
+  if (!plan.region || !("cached" in plan) || typeof plan.cached !== "boolean" || !("revision" in plan) || typeof plan.revision !== "number") {
+    throw new Error("Prepared Flex plan is incompatible with this baseline allocation.");
+  }
+  return plan;
+}
+function stagePreparedChildStyle(child, receiver, content, prepared) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction) return;
+  let pending = snapshots.get(transaction);
+  if (!pending) {
+    pending = /* @__PURE__ */ new WeakMap();
+    snapshots.set(transaction, pending);
+    transaction.onFinish(() => snapshots.delete(transaction));
+  }
+  pending.set(receiver, { child, width: content.width, height: content.height, prepared });
+}
+function takePreparedChildStyle(child, receiver, content) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction || !receiver || !content) return;
+  const pending = snapshots.get(transaction), snapshot = pending?.get(receiver);
+  if (!snapshot || snapshot.child !== child || snapshot.width !== content.width || snapshot.height !== content.height) return;
+  pending.delete(receiver);
+  return snapshot.prepared;
+}
+function hasPreparedChildStyles() {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  return !!transaction && snapshots.has(transaction);
+}
+const boundaryChildren = /* @__PURE__ */ new WeakMap();
+function stagePreparedBoundaryChildren(slot, children) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  let pending = boundaryChildren.get(transaction);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    boundaryChildren.set(transaction, pending);
+    const owned = pending;
+    transaction.onFinish(() => {
+      for (const [slot2, entry] of owned) if (!entry.claimed) slot2.dispose();
+      owned.clear();
+      boundaryChildren.delete(transaction);
+    });
+  }
+  if (pending.has(slot)) throw new Error("Duplicate known layout boundary during preparation.");
+  let needsAllocationParent = false;
+  const numericPlans = plans.get(transaction);
+  for (let index = 0; index < children.length; index++) {
+    const childSlot = getElementMetadata(children[index])?.preparedLayoutSlot;
+    if (childSlot && (numericPlans?.has(childSlot) || pending.get(childSlot)?.needsAllocationParent)) {
+      needsAllocationParent = true;
+      break;
+    }
+  }
+  pending.set(slot, { children, direction: getLayoutDirection(), claimed: false, needsAllocationParent });
+}
+function takePreparedBoundaryChildren(element) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const slot = getElementMetadata(element)?.preparedLayoutSlot;
+  if (!transaction || !slot) return;
+  const entry = boundaryChildren.get(transaction)?.get(slot);
+  if (!entry) return;
+  if (entry.claimed || entry.direction !== getLayoutDirection()) throw new Error("Prepared boundary children are stale.");
+  entry.claimed = true;
+  slot.claimBoundary();
+  return entry.children;
+}
+function preparedBoundaryNeedsAllocationParent(element) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const slot = getElementMetadata(element)?.preparedLayoutSlot;
+  if (!transaction || !slot) return false;
+  return plans.get(transaction)?.has(slot) === true || boundaryChildren.get(transaction)?.get(slot)?.needsAllocationParent === true;
+}
+function retainPreparedBoundarySubtree(element) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const slot = getElementMetadata(element)?.preparedLayoutSlot;
+  if (!transaction || !slot) return;
+  retainPreparedSubtree(slot, plans.get(transaction), boundaryChildren.get(transaction));
+}
+function retainPreparedSubtree(parent, pending, boundaries) {
+  for (const entries of parent.children.values()) for (const child of entries.values()) {
+    const entry = pending?.get(child);
+    if (entry) entry.claimed = true;
+    const boundary = boundaries?.get(child);
+    if (boundary) boundary.claimed = true;
+    retainPreparedSubtree(child, pending, boundaries);
+  }
+}
+function preparePlacedKnownLayout(element, occurrence, parentSlot) {
+  const prepared = peekPreNormalizedStyle(element);
+  if (!prepared) throw new Error("Known layout preparation requires settled receiver inputs.");
+  const settled = prepared.style;
+  const width = settled.width, height = settled.height;
+  if (typeof width !== "number" || typeof height !== "number") throw new Error("Known layout preparation requires settled content geometry.");
+  const slot = preflightKnownLayout(prepared.source, prepared.style, { x: 0, y: 0, width, height }, getPrimitiveReceiverToken(element), occurrence, parentSlot);
+  attachPreparedLayoutSlot(element, slot);
+}
+function prepareKnownLayoutDescendants(plan, parentSlot) {
+  let occurrences;
+  for (let index = 0; index < plan.children.length; index++) {
+    const child = plan.children[index];
+    if (!isKnownLayoutType(child.type) && !isLayoutComponent(child.type)) continue;
+    let occurrence = 0;
+    if (child.key === void 0) {
+      occurrences ??= /* @__PURE__ */ new Map();
+      occurrence = occurrences.get(child.type) ?? 0;
+      occurrences.set(child.type, occurrence + 1);
+    }
+    preparePlacedKnownLayout(plan.placements[index].element, occurrence, parentSlot);
+  }
+}
+const intrinsicMainStages = /* @__PURE__ */ new WeakMap();
+function stagePreparedIntrinsicMain(receiver, stage) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction || !receiver) return;
+  let pending = intrinsicMainStages.get(transaction);
+  if (!pending) {
+    pending = /* @__PURE__ */ new WeakMap();
+    intrinsicMainStages.set(transaction, pending);
+    transaction.onFinish(() => intrinsicMainStages.delete(transaction));
+  }
+  pending.set(receiver, stage);
+}
+function peekPreparedIntrinsicMain(receiver, elements, axis, contentMain, revision) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const stage = transaction && receiver ? intrinsicMainStages.get(transaction)?.get(receiver) : void 0;
+  if (!stage || stage.axis !== axis || stage.contentMain !== contentMain || stage.revision !== revision || stage.elements.length !== elements.length) return;
+  for (let index = 0; index < elements.length; index++) {
+    if (stage.elements[index] !== elements[index]) return;
+  }
+  return stage;
+}
+function takePreparedIntrinsicMain(receiver, elements, axis, contentMain, revision) {
+  const stage = peekPreparedIntrinsicMain(receiver, elements, axis, contentMain, revision);
+  if (stage) intrinsicMainStages.get(GLOBAL_STATE.renderTransaction).delete(receiver);
+  return stage;
+}
+export {
+  PreparedLayoutSlot,
+  attachPreparedLayoutSlot,
+  claimPreparedFlexPlan,
+  claimPreparedLayoutPlan,
+  currentPreparedReceiverSlot,
+  hasPreparedChildStyles,
+  isKnownLayoutType,
+  peekPreparedFlexPlan,
+  peekPreparedIntrinsicMain,
+  peekPreparedLayoutPlan,
+  preflightKnownLayout,
+  prepareKnownLayoutDescendants,
+  preparePlacedKnownLayout,
+  preparedBoundaryNeedsAllocationParent,
+  registerKnownLayoutPreflight,
+  retainPreparedBoundarySubtree,
+  snapshotLayoutTopology,
+  stagePreparedBoundaryChildren,
+  stagePreparedChildStyle,
+  stagePreparedIntrinsicMain,
+  stagePreparedLayoutPlan,
+  takePreparedBoundaryChildren,
+  takePreparedChildStyle,
+  takePreparedIntrinsicMain
+};
+//# sourceMappingURL=prepared-root.js.map