@number10/jsx-core 5.0.0

package/dist/layout/layout-engine.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-engine.cjs","sources":["../../src/layout/layout-engine.ts"],"sourcesContent":["/**\n * Layout engine — main orchestrator for layout calculations.\n *\n * Renderer-neutral. Uses strategy pattern for layout directions.\n * Renderer-specific operations (clipping, background drawing, hit areas)\n * are injected via callbacks.\n *\n * @migration(audit:phase-5f+) Phase 5F+ — moved from @number10/jsx-phaser to @number10/jsx-core.\n *   Phaser-specific parts (stencil clip, background) extracted to callbacks.\n */\nimport type { LayoutProps } from '../core-props'\nimport { normalizeGap } from '../core-props'\nimport { DebugLogger } from '../dev-config'\nimport { getGlobalValue, getOrCreateGlobalValue, setGlobalValue } from '../global-registry'\nimport { applyContainerDimensions } from './appliers/container-applier'\nimport { applyChildPositions } from './appliers/position-applier'\nimport type { LayoutStrategy } from './strategies/base-strategy'\nimport { ColumnLayoutStrategy } from './strategies/column-layout'\nimport { RowLayoutStrategy } from './strategies/row-layout'\nimport { StackLayoutStrategy } from './strategies/stack-layout'\nimport type { LayoutChild, LayoutContainer, LayoutContext, LayoutLine, Position } from './types'\nimport { getChildSize, getMargin, isLayoutChild, processNestedContainer } from './utils/child-utils'\nimport { calculateContainerSize, normalizePadding } from './utils/dimension-calculator'\nimport { distributeFlexSpace, hasFlexChildren } from './utils/flex-distributor'\nimport { clampSize, parseSize, resolveSize } from './utils/size-resolver'\nimport { calculateAlignItems, calculateJustifyContent } from './utils/spacing-calculator'\n\n// ---------------------------------------------------------------------------\n// Renderer-specific callbacks (injected by the renderer package)\n// ---------------------------------------------------------------------------\n\n/**\n * Callback to apply overflow clipping on a container.\n * Each renderer implements its own clipping mechanism (e.g., stencil buffer, scissor rect).\n */\nexport type ApplyOverflowClip = (\n  container: LayoutContainer,\n  containerProps: LayoutProps & {\n    cornerRadius?: number | { tl?: number; tr?: number; bl?: number; br?: number }\n  },\n  width: number,\n  height: number\n) => void\n\n/**\n * Callback invoked after layout dimensions are applied.\n * Used for renderer-specific post-layout operations (background drawing, hit areas).\n */\nexport type AfterLayoutCallback = (\n  container: LayoutContainer,\n  width: number,\n  height: number\n) => void\n\nconst GLOBAL_NS = '@number10/jsx-core:layout'\nconst _overflowClipRegistryKey = Symbol.for(`${GLOBAL_NS}:overflowClipRegistry`)\nconst _onAfterLayoutKey = Symbol.for(`${GLOBAL_NS}:onAfterLayout`)\n\nfunction getOverflowClipRegistry(): ApplyOverflowClip[] {\n  return getOrCreateGlobalValue(_overflowClipRegistryKey, () => [])\n}\n\nfunction getOnAfterLayout(): AfterLayoutCallback {\n  return getGlobalValue<AfterLayoutCallback>(_onAfterLayoutKey) ?? noopAfterLayout\n}\n\nfunction setOnAfterLayout(fn: AfterLayoutCallback): void {\n  setGlobalValue(_onAfterLayoutKey, fn)\n}\n\n/** No-op defaults — renderer must inject real implementations. */\nconst noopAfterLayout: AfterLayoutCallback = () => {}\n\n/**\n * Register a renderer-specific overflow clip implementation.\n * Multiple renderers can each register their own clip; the layout engine\n * tries each one until a handler accepts the container.\n * Prefer this over setApplyOverflowClip for multi-renderer setups.\n */\nexport function registerApplyOverflowClip(fn: ApplyOverflowClip): void {\n  getOverflowClipRegistry().push(fn)\n}\n\n/**\n * Replace all registered overflow clip handlers with a single one.\n * For single-renderer setups. Equivalent to clearing the registry and registering one.\n * @deprecated Prefer registerApplyOverflowClip for multi-renderer safety.\n */\nexport function setApplyOverflowClip(fn: ApplyOverflowClip): void {\n  const registry = getOverflowClipRegistry()\n  registry.length = 0\n  registry.push(fn)\n}\n\n/** Inject the renderer-specific after-layout callback (background, hit area). */\nexport function setAfterLayout(fn: AfterLayoutCallback): void {\n  setOnAfterLayout(fn)\n}\n\n/**\n * Callback function for deferred layout updates\n * Executed after all layouts are complete in next frame\n */\ntype DeferredUpdateCallback = () => void\n\n/**\n * Central processor for deferred layout updates\n * Collects all updates that require final world coordinates or completed parent layouts\n * Executes them in batch via single requestAnimationFrame for optimal performance\n *\n * Use cases:\n * - Overflow mask positioning (needs world coordinates)\n * - Scroll position updates (needs final content size)\n * - Animation initialization (needs final positions)\n * - Custom effects requiring complete layout\n * - Gesture hit area updates (needs final layout size)\n */\nexport class DeferredLayoutQueue {\n  private static callbacks: DeferredUpdateCallback[] = []\n  private static scheduled = false\n\n  /**\n   * Schedule a callback to execute after current layout pass completes\n   * All callbacks are batched and executed in single requestAnimationFrame\n   * @param callback - Function to execute in next frame\n   */\n  static defer(callback: DeferredUpdateCallback): void {\n    this.callbacks.push(callback)\n\n    // Schedule flush if not already scheduled (only 1 requestAnimationFrame per frame)\n    if (!this.scheduled) {\n      this.scheduled = true\n      requestAnimationFrame(() => this.flush())\n    }\n  }\n\n  /**\n   * Execute all pending callbacks in batch\n   * Called once per frame via requestAnimationFrame\n   */\n  private static flush(): void {\n    this.scheduled = false\n\n    // Copy and clear callbacks before execution to prevent infinite loops\n    const callbacks = [...this.callbacks]\n    this.callbacks = []\n\n    // Execute all callbacks with error isolation\n    for (const callback of callbacks) {\n      try {\n        callback()\n      } catch (error) {\n        DebugLogger.error('DeferredLayoutQueue', 'Error in deferred callback:', error)\n      }\n    }\n  }\n}\n\n/**\n * Entry for batched layout calculation\n */\ninterface LayoutBatchEntry {\n  container: LayoutContainer\n  containerProps: LayoutProps\n  parentSize: { width: number; height: number } | undefined\n  parentPadding: { horizontal: number; vertical: number } | undefined\n}\n\n/**\n * Batches layout calculations to reduce redundant recalculations\n * Prevents multiple calculations of same container within single synchronous call stack\n * Does NOT defer to next frame - executes immediately after current stack completes\n *\n * Benefits:\n * - Prevents multiple calculations of same container in one update\n * - Bottom-up execution order prevents redundant parent recalculations\n * - No visual flickering (executes in same frame)\n *\n * Usage:\n * - VDOM patches: LayoutBatchQueue.schedule() instead of direct calculateLayout()\n * - Appliers: LayoutBatchQueue.schedule() instead of direct calculateLayout()\n * - Tests: Set LayoutBatchQueue.synchronous = true for immediate execution\n */\nexport class LayoutBatchQueue {\n  private static pending = new Map<LayoutContainer, LayoutBatchEntry>()\n  private static scheduled = false\n\n  /**\n   * Enable synchronous mode for testing\n   * When true, layouts execute immediately instead of batching\n   */\n  static synchronous = false\n\n  /**\n   * Schedule a layout calculation to execute after current call stack\n   * Uses microtask (Promise) instead of requestAnimationFrame to avoid flickering\n   * If container is already scheduled, updates entry with latest props\n   * @param container - Container to calculate layout for\n   * @param containerProps - Layout props\n   * @param parentSize - Optional parent size for percentage resolution\n   * @param parentPadding - Optional parent padding for fill resolution\n   */\n  static schedule(\n    container: LayoutContainer,\n    containerProps: LayoutProps,\n    parentSize?: { width: number; height: number },\n    parentPadding?: { horizontal: number; vertical: number }\n  ): void {\n    // Synchronous mode for tests - execute immediately\n    if (this.synchronous) {\n      calculateLayoutImmediate(container, containerProps, parentSize, parentPadding)\n      return\n    }\n\n    // Update or add entry (latest props win if scheduled multiple times)\n    this.pending.set(container, { container, containerProps, parentSize, parentPadding })\n\n    // Schedule flush if not already scheduled\n    // Use microtask (Promise.resolve) instead of requestAnimationFrame\n    // This executes in SAME FRAME after current call stack, preventing flickering\n    if (!this.scheduled) {\n      this.scheduled = true\n      Promise.resolve().then(() => this.flush())\n    }\n  }\n\n  /**\n   * Execute all pending layout calculations immediately\n   * Processes in bottom-up order (deepest children first)\n   * This prevents redundant parent recalculations\n   */\n  static flush(): void {\n    this.scheduled = false\n\n    if (this.pending.size === 0) return\n\n    DebugLogger.time('performance', 'LayoutBatchQueue.flush')\n\n    // Copy and clear pending entries\n    const entries = Array.from(this.pending.values())\n    this.pending.clear()\n\n    // Sort bottom-up (deepest containers first)\n    // This ensures children are laid out before parents\n    entries.sort((a, b) => {\n      const depthA = getContainerDepth(a.container)\n      const depthB = getContainerDepth(b.container)\n      return depthB - depthA // Higher depth = deeper = execute first\n    })\n\n    // Execute layout calculations in optimal order\n    for (const entry of entries) {\n      try {\n        // Only calculate if container still exists, is visible, and not destroyed\n        const node = entry.container as LayoutContainer & { destroyed?: boolean }\n        if (node.destroyed === true) continue\n        if (entry.container.visible === false) continue\n        calculateLayoutImmediate(\n          entry.container,\n          entry.containerProps,\n          entry.parentSize,\n          entry.parentPadding\n        )\n      } catch (error) {\n        DebugLogger.error('LayoutBatchQueue', 'Error calculating layout:', error)\n      }\n    }\n\n    DebugLogger.timeEnd('performance', 'LayoutBatchQueue.flush')\n  }\n}\n\n/**\n * Get depth of container in scene hierarchy by walking parent references.\n * Root containers have depth 0, children have depth 1, etc.\n * Requires LayoutNode.parent to be set by the VDOM / mount process.\n * @param container - Container to get depth for\n * @returns Depth level (0 = root)\n */\nfunction getContainerDepth(container: LayoutContainer): number {\n  let depth = 0\n  let current: LayoutContainer | undefined = getLayoutParent(container)\n\n  while (current) {\n    depth++\n    current = getLayoutParent(current)\n  }\n\n  return depth\n}\n\nfunction getLayoutParent(container: LayoutContainer): LayoutContainer | undefined {\n  if (container.__layoutParent) {\n    return container.__layoutParent as LayoutContainer\n  }\n\n  if (container.parent) {\n    return container.parent\n  }\n\n  // Phaser uses parentContainer instead of the renderer-neutral parent field.\n  const parentContainer = (container as Record<string, unknown>).parentContainer\n  if (parentContainer && typeof parentContainer === 'object') {\n    return parentContainer as LayoutContainer\n  }\n\n  return undefined\n}\n\n/**\n * Applies overflow clipping via the renderer-injected callback.\n * Each renderer provides its own clipping implementation.\n */\nfunction applyOverflowMask(\n  container: LayoutContainer,\n  containerProps: LayoutProps & {\n    cornerRadius?: number | { tl?: number; tr?: number; bl?: number; br?: number }\n  },\n  width: number,\n  height: number\n): void {\n  for (const clip of getOverflowClipRegistry()) {\n    clip(container, containerProps, width, height)\n  }\n}\n\n/**\n * Strategy map - reusable strategy instances\n */\nconst strategies: Record<string, LayoutStrategy> = {\n  column: new ColumnLayoutStrategy(),\n  row: new RowLayoutStrategy(),\n  stack: new StackLayoutStrategy(),\n}\n\n/**\n * Invalidates parent layout if container size changed after recalculation\n * Propagates layout changes up the hierarchy to ensure parent containers adapt\n * @param container - Container that was just laid out\n * @param oldSize - Size before layout calculation\n * @param newWidth - New width after layout\n * @param newHeight - New height after layout\n */\ntype LayoutSize = { width: number; height: number }\ntype LayoutCycleState = {\n  last: LayoutSize\n  prev?: LayoutSize\n  count: number\n  lastTime: number\n}\n\nconst LAYOUT_CYCLE_EPSILON = 0.5\nconst LAYOUT_CYCLE_TIME_MS = 20\nconst LAYOUT_CYCLE_MAX = 5\nconst LAYOUT_MAX_SIZE = 200000\nconst layoutCycleGuard = new WeakMap<LayoutContainer, LayoutCycleState>()\nconst deferredParentInvalidations = new WeakSet<LayoutContainer>()\n\nfunction isCloseSize(a: LayoutSize, b: LayoutSize, epsilon: number): boolean {\n  return Math.abs(a.width - b.width) < epsilon && Math.abs(a.height - b.height) < epsilon\n}\n\nfunction invalidateParentLayoutIfNeeded(\n  container: LayoutContainer,\n  oldSize: { width: number; height: number } | undefined,\n  newWidth: number,\n  newHeight: number\n): void {\n  // Skip if no old size (first layout) or size unchanged\n  if (\n    !oldSize ||\n    (Math.abs(oldSize.width - newWidth) < LAYOUT_CYCLE_EPSILON &&\n      Math.abs(oldSize.height - newHeight) < LAYOUT_CYCLE_EPSILON)\n  ) {\n    return\n  }\n\n  if (\n    !Number.isFinite(newWidth) ||\n    !Number.isFinite(newHeight) ||\n    newWidth > LAYOUT_MAX_SIZE ||\n    newHeight > LAYOUT_MAX_SIZE\n  ) {\n    DebugLogger.warn('layout', 'Runaway layout size detected, skipping parent invalidation', {\n      oldSize,\n      newSize: { width: newWidth, height: newHeight },\n      containerProps: container.__layoutProps,\n      childCount: (container.list as unknown[])?.length ?? 0,\n    })\n    return\n  }\n\n  const newSize = { width: newWidth, height: newHeight }\n  const now = Date.now()\n\n  // Size changed - need to recalculate parent layout\n  const parent = getLayoutParent(container) as\n    | (LayoutContainer & {\n        __layoutProps?: LayoutProps\n        __getLayoutSize?: () => { width: number; height: number }\n      })\n    | undefined\n\n  if (!parent || !parent.__layoutProps) {\n    return // No layout parent to invalidate\n  }\n\n  const guard = layoutCycleGuard.get(container)\n  if (guard) {\n    const repeatsPrev = guard.prev ? isCloseSize(guard.prev, newSize, LAYOUT_CYCLE_EPSILON) : false\n    if (repeatsPrev && now - guard.lastTime < LAYOUT_CYCLE_TIME_MS) {\n      guard.count += 1\n    } else {\n      guard.count = 0\n    }\n    guard.prev = guard.last\n    guard.last = newSize\n    guard.lastTime = now\n    layoutCycleGuard.set(container, guard)\n\n    if (guard.count >= LAYOUT_CYCLE_MAX) {\n      DebugLogger.log('layout', 'Layout cycle detected, deferring parent invalidation', {\n        container,\n        oldSize,\n        newSize,\n      })\n      guard.count = 0\n      guard.lastTime = 0\n      layoutCycleGuard.set(container, guard)\n      deferParentLayoutInvalidation(container)\n      return\n    }\n  } else {\n    layoutCycleGuard.set(container, {\n      last: newSize,\n      count: 0,\n      lastTime: now,\n    })\n  }\n\n  DebugLogger.log(\n    'layout',\n    'Container size changed, invalidating parent:',\n    `${oldSize.width}x${oldSize.height} -> ${newWidth}x${newHeight}`\n  )\n  invalidateParentLayout(container)\n}\n\nfunction deferParentLayoutInvalidation(container: LayoutContainer): void {\n  if (deferredParentInvalidations.has(container)) {\n    return\n  }\n\n  deferredParentInvalidations.add(container)\n  DeferredLayoutQueue.defer(() => {\n    deferredParentInvalidations.delete(container)\n    invalidateParentLayout(container)\n  })\n}\n\nfunction invalidateParentLayout(container: LayoutContainer): void {\n  const parent = getLayoutParent(container) as\n    | (LayoutContainer & {\n        __layoutProps?: LayoutProps\n        __getLayoutSize?: () => { width: number; height: number }\n      })\n    | undefined\n\n  if (!parent || !parent.__layoutProps) {\n    return\n  }\n\n  const grandParent = getLayoutParent(parent) as\n    | (LayoutContainer & {\n        __layoutProps?: LayoutProps\n        __getLayoutSize?: () => { width: number; height: number }\n      })\n    | undefined\n\n  let grandParentSize: { width: number; height: number } | undefined\n  if (grandParent && grandParent.__getLayoutSize) {\n    const totalSize = grandParent.__getLayoutSize()\n    const padding = (grandParent.__layoutProps?.padding ?? 0) as\n      | number\n      | { left?: number; right?: number; top?: number; bottom?: number }\n    const normPadding =\n      typeof padding === 'number'\n        ? { left: padding, right: padding, top: padding, bottom: padding }\n        : {\n            left: padding.left ?? 0,\n            right: padding.right ?? 0,\n            top: padding.top ?? 0,\n            bottom: padding.bottom ?? 0,\n          }\n    grandParentSize = {\n      width: totalSize.width - normPadding.left - normPadding.right,\n      height: totalSize.height - normPadding.top - normPadding.bottom,\n    }\n  }\n\n  calculateLayout(parent, parent.__layoutProps, grandParentSize)\n}\n\n/**\n * Calculate layout for a container and its children immediately (internal)\n * DO NOT CALL DIRECTLY - Use calculateLayout() which batches for performance\n * @param container - Phaser container with children\n * @param containerProps - Layout props of the container\n * @param parentSize - Optional parent dimensions for percentage resolution\n * @param parentPadding - Optional parent padding for 'fill' resolution\n */\nfunction calculateLayoutImmediate(\n  container: LayoutContainer,\n  containerProps: LayoutProps,\n  parentSize?: { width: number; height: number },\n  parentPadding?: { horizontal: number; vertical: number }\n): void {\n  const children = (container.list ?? []) as LayoutContainer[]\n\n  // Store old size before layout calculation for parent invalidation\n  const containerWithLayout = container as typeof container & {\n    __getLayoutSize?: () => { width: number; height: number }\n  }\n  const oldContainerSize = containerWithLayout.__getLayoutSize?.()\n\n  // Debug: Track excessive layout calls\n  // console.log('[LAYOUT] calculateLayout called for container with', children?.length ?? 0, 'children')\n\n  if (!children || !Array.isArray(children)) {\n    return\n  }\n\n  // Performance timing\n  DebugLogger.time('performance', 'calculateLayout')\n\n  // 1. Extract layout parameters\n  const direction = containerProps.direction ?? 'column'\n  const padding = normalizePadding(containerProps.padding)\n  const gap = normalizeGap(containerProps.gap)\n  const justifyContent = containerProps.justifyContent ?? 'start'\n\n  DebugLogger.log('layout', `Direction: ${direction}, Padding:`, padding)\n\n  // 2a. Pre-calculate container size if possible (needed for percentage children and nested containers)\n  //     This allows percentage-based child sizes to resolve correctly and nested containers\n  //     to receive the correct content-area as their parent size\n  let currentContainerSize: { width: number; height: number } | undefined\n\n  // Try to calculate width early if we have explicit width or can resolve from parent\n  const parsedWidth = parseSize(containerProps.width)\n  const canCalculateWidth =\n    parsedWidth.type === 'fixed' ||\n    (parentSize?.width !== undefined &&\n      (parsedWidth.type === 'percent' ||\n        parsedWidth.type === 'fill' ||\n        parsedWidth.type === 'calc'))\n\n  const width = canCalculateWidth\n    ? resolveSize(parsedWidth, parentSize?.width, container.width, parentPadding?.horizontal)\n    : undefined\n\n  // Try to calculate height early if we have explicit height or can resolve from parent\n  const parsedHeight = parseSize(containerProps.height)\n  const canCalculateHeight =\n    parsedHeight.type === 'fixed' ||\n    (parentSize?.height !== undefined &&\n      (parsedHeight.type === 'percent' ||\n        parsedHeight.type === 'fill' ||\n        parsedHeight.type === 'calc'))\n\n  const height = canCalculateHeight\n    ? resolveSize(parsedHeight, parentSize?.height, container.height, parentPadding?.vertical)\n    : undefined\n\n  // Set currentContainerSize if we could calculate at least one dimension\n  if (width !== undefined || height !== undefined) {\n    // Apply constraints\n    const clampedWidth =\n      width !== undefined\n        ? clampSize(\n            width,\n            containerProps.minWidth,\n            containerProps.maxWidth,\n            parentSize?.width,\n            container.width,\n            parentPadding?.horizontal\n          )\n        : (container.width ?? 0)\n    const clampedHeight =\n      height !== undefined\n        ? clampSize(\n            height,\n            containerProps.minHeight,\n            containerProps.maxHeight,\n            parentSize?.height,\n            container.height,\n            parentPadding?.vertical\n          )\n        : (container.height ?? 0)\n\n    currentContainerSize = {\n      width: clampedWidth,\n      height: clampedHeight,\n    }\n  }\n\n  // Calculate available content size (container minus padding) for child size resolution\n  // This allows 'fill' and percentage sizes to resolve correctly relative to content area\n  const availableContentSize = currentContainerSize\n    ? {\n        width: currentContainerSize.width - padding.left - padding.right,\n        height: currentContainerSize.height - padding.top - padding.bottom,\n      }\n    : undefined\n\n  DebugLogger.log('layout', 'Pre-calculated container size:', currentContainerSize)\n  DebugLogger.log('layout', 'Available content size (for fill):', availableContentSize)\n\n  // 2. Prepare layout children (filter backgrounds, headless objects, process nested containers)\n  const layoutChildren: LayoutChild[] = []\n\n  for (const child of children) {\n    // Skip non-layout children (backgrounds, headless objects, missing __getLayoutSize)\n    if (!isLayoutChild(child)) {\n      DebugLogger.log('layout', 'Skipping non-layout child:', {\n        isBackground: child.__isBackground,\n        headless: child.__layoutProps?.headless,\n        hasLayoutSize: typeof child.__getLayoutSize === 'function',\n      })\n      continue\n    } // Skip processing nested containers with flex (they need parent size first)\n    const hasFlex = (child.__layoutProps?.flex ?? 0) > 0\n    if (!hasFlex) {\n      // Process nested containers - pass content-area (size minus padding) as parent size\n      // This ensures nested children see the correct available space\n      const parentSizeForNested = currentContainerSize\n        ? {\n            width: currentContainerSize.width - padding.left - padding.right,\n            height: currentContainerSize.height - padding.top - padding.bottom,\n          }\n        : parentSize\n          ? {\n              width: parentSize.width - (parentPadding?.horizontal ?? 0),\n              height: parentSize.height - (parentPadding?.vertical ?? 0),\n            }\n          : undefined\n\n      processNestedContainer(\n        child,\n        calculateLayout,\n        parentSizeForNested,\n        undefined // No padding offset needed since we pass content-area\n      )\n    }\n\n    // Get child size - pass content-area (container size minus padding) for % and fill\n    // This way percentages and fill are relative to available content space\n    const contentAreaForChild = currentContainerSize\n      ? {\n          width: currentContainerSize.width - padding.left - padding.right,\n          height: currentContainerSize.height - padding.top - padding.bottom,\n        }\n      : parentSize\n        ? {\n            width: parentSize.width - (parentPadding?.horizontal ?? 0),\n            height: parentSize.height - (parentPadding?.vertical ?? 0),\n          }\n        : undefined\n\n    const size = getChildSize(child, contentAreaForChild, undefined)\n    const margin = getMargin(child)\n\n    layoutChildren.push({ child, size, margin })\n  }\n\n  // 3. Select strategy based on direction\n  const strategy = strategies[direction]\n  if (!strategy) {\n    DebugLogger.error('Layout', `Unknown direction: ${direction}`)\n    return\n  }\n\n  // 4. Build layout context (will be used after we know container dimensions)\n  const contextPartial = {\n    containerProps,\n    padding,\n    gap,\n    children: layoutChildren,\n  }\n\n  // 5. Calculate metrics using strategy\n  const metrics = strategy.calculateMetrics(layoutChildren, contextPartial as LayoutContext)\n\n  // 5a. Check if wrapping is enabled\n  const flexWrap = containerProps.flexWrap ?? 'nowrap'\n  const shouldWrap = flexWrap !== 'nowrap' && direction !== 'stack'\n\n  // 6. Calculate container dimensions (with parent size and padding for resolution)\n  const { width: containerWidth, height: containerHeight } = calculateContainerSize(\n    containerProps,\n    metrics,\n    padding,\n    direction,\n    gap,\n    layoutChildren.length,\n    parentSize,\n    parentPadding\n  )\n\n  // 6a. Distribute flex space if there are flex children (skip if wrapping - will be done per line)\n  let finalLayoutChildren = layoutChildren\n  if (hasFlexChildren(layoutChildren) && !shouldWrap) {\n    const contentSize =\n      direction === 'row'\n        ? containerWidth - padding.left - padding.right\n        : containerHeight - padding.top - padding.bottom\n\n    // Subtract gap space (gap appears between children, so n-1 gaps for n children)\n    const gapValue = direction === 'row' ? gap.horizontal : gap.vertical\n    const totalGapSpace = layoutChildren.length > 1 ? gapValue * (layoutChildren.length - 1) : 0\n    const availableMainSpace = contentSize - totalGapSpace\n\n    finalLayoutChildren = distributeFlexSpace(layoutChildren, availableMainSpace, direction)\n\n    // Process nested flex containers now that they have their size\n    for (const layoutChild of finalLayoutChildren) {\n      const props = layoutChild.child.__layoutProps\n      const isFlexItem =\n        (props?.flex !== undefined && props.flex > 0) ||\n        props?.flexShrink !== undefined ||\n        props?.flexBasis !== undefined\n      if (isFlexItem) {\n        // Temporarily set explicit size based on flex calculation\n        const originalProps = { ...layoutChild.child.__layoutProps }\n        if (direction === 'row') {\n          layoutChild.child.__layoutProps = {\n            ...layoutChild.child.__layoutProps,\n            width: layoutChild.size.width,\n          }\n        } else {\n          layoutChild.child.__layoutProps = {\n            ...layoutChild.child.__layoutProps,\n            height: layoutChild.size.height,\n          }\n        }\n\n        processNestedContainer(\n          layoutChild.child,\n          calculateLayout,\n          {\n            width: containerWidth,\n            height: containerHeight,\n          },\n          {\n            horizontal: padding.left + padding.right,\n            vertical: padding.top + padding.bottom,\n          }\n        )\n\n        // Restore original props\n        layoutChild.child.__layoutProps = originalProps\n      }\n    }\n\n    // Recalculate metrics with updated sizes\n    const updatedMetrics = strategy.calculateMetrics(\n      finalLayoutChildren,\n      contextPartial as LayoutContext\n    )\n    metrics.totalMainSize = updatedMetrics.totalMainSize\n    if (direction === 'column') {\n      metrics.maxWidth = updatedMetrics.maxWidth\n    } else if (direction === 'row') {\n      metrics.maxHeight = updatedMetrics.maxHeight\n    }\n  }\n\n  // 7. Calculate content area\n  const contentArea = {\n    width: containerWidth - padding.left - padding.right,\n    height: containerHeight - padding.top - padding.bottom,\n  }\n\n  // 8. Complete layout context\n  const context: LayoutContext = {\n    ...contextPartial,\n    children: finalLayoutChildren,\n    contentArea,\n    parentSize: {\n      width: containerWidth,\n      height: containerHeight,\n    },\n  }\n\n  // 9. Calculate spacing for justifyContent\n  const availableMainSpace = direction === 'row' ? contentArea.width : contentArea.height\n  // Calculate total gap space (gaps between children, not before first or after last)\n  const gapValue = direction === 'row' ? gap.horizontal : gap.vertical\n  const totalGapSpace =\n    finalLayoutChildren.length > 1 ? gapValue * (finalLayoutChildren.length - 1) : 0\n  const remainingSpace = availableMainSpace - metrics.totalMainSize - totalGapSpace\n\n  let mainStart = 0\n  let spaceBetween = 0\n\n  // For stack direction, justifyContent is not applicable\n  if (direction !== 'stack') {\n    const justifyResult = calculateJustifyContent(\n      justifyContent,\n      remainingSpace,\n      finalLayoutChildren.length\n    )\n    mainStart = justifyResult.mainStart\n    spaceBetween = justifyResult.spaceBetween\n  }\n\n  // 9a. Apply stretch if alignItems is 'stretch'\n  const alignItems = containerProps.alignItems ?? 'start'\n  if (alignItems === 'stretch' && direction !== 'stack') {\n    for (const layoutChild of finalLayoutChildren) {\n      const margin = getMargin(layoutChild.child)\n      const child = layoutChild.child\n\n      if (direction === 'row') {\n        // Stretch height to full cross-axis (minus margins)\n        const stretchHeight = contentArea.height - (margin.top ?? 0) - (margin.bottom ?? 0)\n        layoutChild.size.height = Math.max(0, stretchHeight)\n\n        // If child is a container with layout props, update its height prop and recalculate nested layout\n        if (child.__layoutProps) {\n          const originalHeight = child.__layoutProps.height\n          child.__layoutProps = { ...child.__layoutProps, height: stretchHeight }\n\n          // Recalculate nested container layout with new height\n          processNestedContainer(child, calculateLayout, {\n            width: containerWidth,\n            height: containerHeight,\n          })\n\n          // Restore original height prop (in case it was percentage or undefined)\n          child.__layoutProps = { ...child.__layoutProps, height: originalHeight }\n        }\n      } else if (direction === 'column') {\n        // Stretch width to full cross-axis (minus margins)\n        const stretchWidth = contentArea.width - (margin.left ?? 0) - (margin.right ?? 0)\n        layoutChild.size.width = Math.max(0, stretchWidth)\n\n        // If child is a container with layout props, update its width prop and recalculate nested layout\n        if (child.__layoutProps) {\n          const originalWidth = child.__layoutProps.width\n          child.__layoutProps = { ...child.__layoutProps, width: stretchWidth }\n\n          // Recalculate nested container layout with new width\n          processNestedContainer(child, calculateLayout, {\n            width: containerWidth,\n            height: containerHeight,\n          })\n\n          // Restore original width prop (in case it was percentage or undefined)\n          child.__layoutProps = { ...child.__layoutProps, width: originalWidth }\n        }\n      }\n    }\n  }\n\n  // 10. Handle wrapping if enabled\n  const positions: Position[] = []\n  let adjustedContainerWidth = containerWidth\n  let adjustedContainerHeight = containerHeight\n\n  if (shouldWrap && 'wrapChildren' in strategy) {\n    // Wrap children into multiple lines\n    const availableMainSize = direction === 'row' ? contentArea.width : contentArea.height\n    const mainGapValue = direction === 'row' ? gap.horizontal : gap.vertical\n    const lines = (strategy as RowLayoutStrategy | ColumnLayoutStrategy).wrapChildren(\n      finalLayoutChildren,\n      availableMainSize,\n      mainGapValue\n    )\n\n    if (flexWrap === 'wrap-reverse') {\n      lines.reverse()\n    }\n\n    // Calculate total cross size needed for all lines\n    const totalCrossSize = lines.reduce(\n      (sum: number, line: LayoutLine) => sum + line.crossAxisSize,\n      0\n    )\n    const crossGapValue = direction === 'row' ? gap.vertical : gap.horizontal\n    const totalLineGaps = (lines.length - 1) * crossGapValue\n\n    // Adjust container dimensions if auto-sizing and wrapping occurred\n    if (\n      direction === 'row' &&\n      (containerProps.height === undefined || containerProps.height === 'auto')\n    ) {\n      // For row direction with auto-height, calculate height based on wrapped lines\n      adjustedContainerHeight = totalCrossSize + totalLineGaps + padding.top + padding.bottom\n    } else if (\n      direction === 'column' &&\n      (containerProps.width === undefined || containerProps.width === 'auto')\n    ) {\n      // For column direction with auto-width, calculate width based on wrapped lines\n      adjustedContainerWidth = totalCrossSize + totalLineGaps + padding.left + padding.right\n    }\n\n    const availableCrossSize = direction === 'row' ? contentArea.height : contentArea.width\n    const freeCrossSpace = availableCrossSize - totalCrossSize - totalLineGaps\n\n    // Apply alignContent to distribute lines\n    const alignContent = containerProps.alignContent ?? 'stretch'\n    let crossOffset = 0\n    let lineCrossSpacing = 0\n\n    if (alignContent === 'center') {\n      crossOffset = freeCrossSpace / 2\n    } else if (alignContent === 'end') {\n      crossOffset = freeCrossSpace\n    } else if (alignContent === 'space-between' && lines.length > 1) {\n      lineCrossSpacing = freeCrossSpace / (lines.length - 1)\n    } else if (alignContent === 'space-around') {\n      lineCrossSpacing = freeCrossSpace / lines.length\n      crossOffset = lineCrossSpacing / 2\n    }\n\n    // Position children line by line\n    for (const line of lines) {\n      // Apply flex distribution per line if line has flex children\n      let lineChildren = line.children\n      if (hasFlexChildren(line.children)) {\n        const lineGapSpace = (line.children.length - 1) * mainGapValue\n        const lineAvailableSpace = availableMainSize - lineGapSpace\n        lineChildren = distributeFlexSpace(line.children, lineAvailableSpace, direction)\n\n        // Update line main size after flex distribution\n        line.mainAxisSize = lineChildren.reduce((sum: number, child: LayoutChild) => {\n          const size = direction === 'row' ? child.size.width : child.size.height\n          const margin = getMargin(child.child)\n          const marginSize =\n            direction === 'row'\n              ? (margin.left ?? 0) + (margin.right ?? 0)\n              : (margin.top ?? 0) + (margin.bottom ?? 0)\n          return sum + size + marginSize\n        }, 0)\n      }\n\n      // Calculate line-specific justifyContent\n      const lineMainSize = line.mainAxisSize\n      const lineAvailableMain = availableMainSize\n      const lineRemainingSpace = lineAvailableMain - lineMainSize\n      const lineGapSpace = (line.children.length - 1) * mainGapValue\n      const lineFreeSpace = lineRemainingSpace - lineGapSpace\n\n      const lineJustifyResult = calculateJustifyContent(\n        justifyContent,\n        lineFreeSpace,\n        line.children.length\n      )\n\n      let lineMainOffset = lineJustifyResult.mainStart\n      const lineSpaceBetween = lineJustifyResult.spaceBetween\n\n      // Position each child in the line\n      for (let i = 0; i < lineChildren.length; i++) {\n        const child = lineChildren[i]\n        if (!child) continue\n\n        const margin = getMargin(child.child)\n\n        let x: number\n        let y: number\n\n        if (direction === 'row') {\n          // Main axis: horizontal\n          lineMainOffset += margin.left ?? 0\n          x = padding.left + lineMainOffset\n\n          // Cross axis: vertical\n          const childCrossOffset = calculateAlignItems(\n            alignItems,\n            line.crossAxisSize,\n            child.size.height,\n            margin.top ?? 0,\n            margin.bottom ?? 0\n          )\n          y = padding.top + crossOffset + childCrossOffset\n\n          lineMainOffset += child.size.width + (margin.right ?? 0)\n          if (i < lineChildren.length - 1) {\n            lineMainOffset += mainGapValue + lineSpaceBetween\n          }\n        } else {\n          // Main axis: vertical\n          lineMainOffset += margin.top ?? 0\n          y = padding.top + lineMainOffset\n\n          // Cross axis: horizontal\n          const childCrossOffset = calculateAlignItems(\n            alignItems,\n            line.crossAxisSize,\n            child.size.width,\n            margin.left ?? 0,\n            margin.right ?? 0\n          )\n          x = padding.left + crossOffset + childCrossOffset\n\n          lineMainOffset += child.size.height + (margin.bottom ?? 0)\n          if (i < lineChildren.length - 1) {\n            lineMainOffset += mainGapValue + lineSpaceBetween\n          }\n        }\n\n        // Find child index in original array for correct position assignment\n        const childIndex = finalLayoutChildren.indexOf(child)\n        if (childIndex !== -1) {\n          positions[childIndex] = { x, y }\n        }\n      }\n\n      // Move to next line\n      crossOffset += line.crossAxisSize + crossGapValue + lineCrossSpacing\n    }\n  } else {\n    // No wrapping - use original single-line positioning\n    let currentMain = mainStart\n\n    for (let i = 0; i < finalLayoutChildren.length; i++) {\n      const child = finalLayoutChildren[i]\n      if (!child) continue\n\n      const result = strategy.positionChild(child, i, context, currentMain)\n\n      positions.push(result.position)\n      currentMain = result.nextMain\n\n      // Add gap and space-between spacing (not for stack)\n      if (direction !== 'stack' && i < finalLayoutChildren.length - 1) {\n        currentMain += gapValue + spaceBetween\n      }\n    }\n  }\n\n  // 11. Apply positions to children\n  applyChildPositions(finalLayoutChildren, positions)\n\n  // 12. Apply container dimensions (use adjusted dimensions if wrapping changed them)\n  applyContainerDimensions(container, adjustedContainerWidth, adjustedContainerHeight)\n\n  // 13. Invoke after-layout callback (renderer-specific: background, hit area)\n  getOnAfterLayout()(container, adjustedContainerWidth, adjustedContainerHeight)\n\n  // 14. Apply overflow mask if needed\n  applyOverflowMask(container, containerProps, adjustedContainerWidth, adjustedContainerHeight)\n\n  // End performance timing\n  DebugLogger.timeEnd('performance', 'calculateLayout')\n\n  // 15. Propagate layout changes to parent if size changed\n  // This ensures parent containers resize when child content changes\n  invalidateParentLayoutIfNeeded(\n    container,\n    oldContainerSize,\n    adjustedContainerWidth,\n    adjustedContainerHeight\n  )\n}\n\n/**\n * Calculate layout for a container and its children\n * Batches layout calculations for optimal performance\n * Multiple calls within same frame are deduplicated and executed bottom-up\n * @param container - Phaser container with children\n * @param containerProps - Layout props of the container\n * @param parentSize - Optional parent dimensions for percentage resolution\n * @param parentPadding - Optional parent padding for 'fill' resolution\n */\n/**\n * Main entry point for layout calculation.\n *\n * @param container - Container node to layout (satisfies LayoutContainer via duck-typing)\n * @param containerProps - Layout properties\n * @param parentSize - Parent dimensions for percentage/fill resolution (optional)\n * @param parentPadding - Parent padding for fill resolution (optional)\n *\n * @migration(audit:scene-portal-mount) Phase 2 — LayoutContainer replaces Phaser.GameObjects.Container\n */\nexport function calculateLayout(\n  container: LayoutContainer,\n  containerProps: LayoutProps,\n  parentSize?: { width: number; height: number },\n  parentPadding?: { horizontal: number; vertical: number }\n): void {\n  LayoutBatchQueue.schedule(container, containerProps, parentSize, parentPadding)\n}\n"],"names":["getOrCreateGlobalValue","getGlobalValue","setGlobalValue","DebugLogger","ColumnLayoutStrategy","RowLayoutStrategy","StackLayoutStrategy","normalizePadding","normalizeGap","parseSize","resolveSize","clampSize","isLayoutChild","processNestedContainer","getChildSize","getMargin","calculateContainerSize","hasFlexChildren","gapValue","totalGapSpace","availableMainSpace","distributeFlexSpace","calculateJustifyContent","lineGapSpace","calculateAlignItems","applyChildPositions","applyContainerDimensions"],"mappings":";;;;;;;;;;;;;;;AAsDA,MAAM,YAAY;AAClB,MAAM,2BAA2B,uBAAO,IAAI,GAAG,SAAS,uBAAuB;AAC/E,MAAM,oBAAoB,uBAAO,IAAI,GAAG,SAAS,gBAAgB;AAEjE,SAAS,0BAA+C;AACtD,SAAOA,eAAAA,uBAAuB,0BAA0B,MAAM,EAAE;AAClE;AAEA,SAAS,mBAAwC;AAC/C,SAAOC,eAAAA,eAAoC,iBAAiB,KAAK;AACnE;AAEA,SAAS,iBAAiB,IAA+B;AACvDC,iBAAAA,eAAe,mBAAmB,EAAE;AACtC;AAGA,MAAM,kBAAuC,MAAM;AAAC;AAQ7C,SAAS,0BAA0B,IAA6B;AACrE,0BAAA,EAA0B,KAAK,EAAE;AACnC;AAOO,SAAS,qBAAqB,IAA6B;AAChE,QAAM,WAAW,wBAAA;AACjB,WAAS,SAAS;AAClB,WAAS,KAAK,EAAE;AAClB;AAGO,SAAS,eAAe,IAA+B;AAC5D,mBAAiB,EAAE;AACrB;AAoBO,MAAM,oBAAoB;AAAA,EAC/B,OAAe,YAAsC,CAAA;AAAA,EACrD,OAAe,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO3B,OAAO,MAAM,UAAwC;AACnD,SAAK,UAAU,KAAK,QAAQ;AAG5B,QAAI,CAAC,KAAK,WAAW;AACnB,WAAK,YAAY;AACjB,4BAAsB,MAAM,KAAK,OAAO;AAAA,IAC1C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAe,QAAc;AAC3B,SAAK,YAAY;AAGjB,UAAM,YAAY,CAAC,GAAG,KAAK,SAAS;AACpC,SAAK,YAAY,CAAA;AAGjB,eAAW,YAAY,WAAW;AAChC,UAAI;AACF,iBAAA;AAAA,MACF,SAAS,OAAO;AACdC,kBAAAA,YAAY,MAAM,uBAAuB,+BAA+B,KAAK;AAAA,MAC/E;AAAA,IACF;AAAA,EACF;AACF;AA2BO,MAAM,iBAAiB;AAAA,EAC5B,OAAe,UAAU,oBAAI,IAAA;AAAA,EAC7B,OAAe,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3B,OAAO,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,OAAO,SACL,WACA,gBACA,YACA,eACM;AAEN,QAAI,KAAK,aAAa;AACpB,+BAAyB,WAAW,gBAAgB,YAAY,aAAa;AAC7E;AAAA,IACF;AAGA,SAAK,QAAQ,IAAI,WAAW,EAAE,WAAW,gBAAgB,YAAY,eAAe;AAKpF,QAAI,CAAC,KAAK,WAAW;AACnB,WAAK,YAAY;AACjB,cAAQ,UAAU,KAAK,MAAM,KAAK,OAAO;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,QAAc;AACnB,SAAK,YAAY;AAEjB,QAAI,KAAK,QAAQ,SAAS,EAAG;AAE7BA,0BAAY,KAAK,eAAe,wBAAwB;AAGxD,UAAM,UAAU,MAAM,KAAK,KAAK,QAAQ,QAAQ;AAChD,SAAK,QAAQ,MAAA;AAIb,YAAQ,KAAK,CAAC,GAAG,MAAM;AACrB,YAAM,SAAS,kBAAkB,EAAE,SAAS;AAC5C,YAAM,SAAS,kBAAkB,EAAE,SAAS;AAC5C,aAAO,SAAS;AAAA,IAClB,CAAC;AAGD,eAAW,SAAS,SAAS;AAC3B,UAAI;AAEF,cAAM,OAAO,MAAM;AACnB,YAAI,KAAK,cAAc,KAAM;AAC7B,YAAI,MAAM,UAAU,YAAY,MAAO;AACvC;AAAA,UACE,MAAM;AAAA,UACN,MAAM;AAAA,UACN,MAAM;AAAA,UACN,MAAM;AAAA,QAAA;AAAA,MAEV,SAAS,OAAO;AACdA,kBAAAA,YAAY,MAAM,oBAAoB,6BAA6B,KAAK;AAAA,MAC1E;AAAA,IACF;AAEAA,0BAAY,QAAQ,eAAe,wBAAwB;AAAA,EAC7D;AACF;AASA,SAAS,kBAAkB,WAAoC;AAC7D,MAAI,QAAQ;AACZ,MAAI,UAAuC,gBAAgB,SAAS;AAEpE,SAAO,SAAS;AACd;AACA,cAAU,gBAAgB,OAAO;AAAA,EACnC;AAEA,SAAO;AACT;AAEA,SAAS,gBAAgB,WAAyD;AAChF,MAAI,UAAU,gBAAgB;AAC5B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,UAAU,QAAQ;AACpB,WAAO,UAAU;AAAA,EACnB;AAGA,QAAM,kBAAmB,UAAsC;AAC/D,MAAI,mBAAmB,OAAO,oBAAoB,UAAU;AAC1D,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAMA,SAAS,kBACP,WACA,gBAGA,OACA,QACM;AACN,aAAW,QAAQ,2BAA2B;AAC5C,SAAK,WAAW,gBAAgB,OAAO,MAAM;AAAA,EAC/C;AACF;AAKA,MAAM,aAA6C;AAAA,EACjD,QAAQ,IAAIC,aAAAA,qBAAA;AAAA,EACZ,KAAK,IAAIC,UAAAA,kBAAA;AAAA,EACT,OAAO,IAAIC,YAAAA,oBAAA;AACb;AAkBA,MAAM,uBAAuB;AAC7B,MAAM,uBAAuB;AAC7B,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,uCAAuB,QAAA;AAC7B,MAAM,kDAAkC,QAAA;AAExC,SAAS,YAAY,GAAe,GAAe,SAA0B;AAC3E,SAAO,KAAK,IAAI,EAAE,QAAQ,EAAE,KAAK,IAAI,WAAW,KAAK,IAAI,EAAE,SAAS,EAAE,MAAM,IAAI;AAClF;AAEA,SAAS,+BACP,WACA,SACA,UACA,WACM;AAEN,MACE,CAAC,WACA,KAAK,IAAI,QAAQ,QAAQ,QAAQ,IAAI,wBACpC,KAAK,IAAI,QAAQ,SAAS,SAAS,IAAI,sBACzC;AACA;AAAA,EACF;AAEA,MACE,CAAC,OAAO,SAAS,QAAQ,KACzB,CAAC,OAAO,SAAS,SAAS,KAC1B,WAAW,mBACX,YAAY,iBACZ;AACAH,0BAAY,KAAK,UAAU,8DAA8D;AAAA,MACvF;AAAA,MACA,SAAS,EAAE,OAAO,UAAU,QAAQ,UAAA;AAAA,MACpC,gBAAgB,UAAU;AAAA,MAC1B,YAAa,UAAU,MAAoB,UAAU;AAAA,IAAA,CACtD;AACD;AAAA,EACF;AAEA,QAAM,UAAU,EAAE,OAAO,UAAU,QAAQ,UAAA;AAC3C,QAAM,MAAM,KAAK,IAAA;AAGjB,QAAM,SAAS,gBAAgB,SAAS;AAOxC,MAAI,CAAC,UAAU,CAAC,OAAO,eAAe;AACpC;AAAA,EACF;AAEA,QAAM,QAAQ,iBAAiB,IAAI,SAAS;AAC5C,MAAI,OAAO;AACT,UAAM,cAAc,MAAM,OAAO,YAAY,MAAM,MAAM,SAAS,oBAAoB,IAAI;AAC1F,QAAI,eAAe,MAAM,MAAM,WAAW,sBAAsB;AAC9D,YAAM,SAAS;AAAA,IACjB,OAAO;AACL,YAAM,QAAQ;AAAA,IAChB;AACA,UAAM,OAAO,MAAM;AACnB,UAAM,OAAO;AACb,UAAM,WAAW;AACjB,qBAAiB,IAAI,WAAW,KAAK;AAErC,QAAI,MAAM,SAAS,kBAAkB;AACnCA,4BAAY,IAAI,UAAU,wDAAwD;AAAA,QAChF;AAAA,QACA;AAAA,QACA;AAAA,MAAA,CACD;AACD,YAAM,QAAQ;AACd,YAAM,WAAW;AACjB,uBAAiB,IAAI,WAAW,KAAK;AACrC,oCAA8B,SAAS;AACvC;AAAA,IACF;AAAA,EACF,OAAO;AACL,qBAAiB,IAAI,WAAW;AAAA,MAC9B,MAAM;AAAA,MACN,OAAO;AAAA,MACP,UAAU;AAAA,IAAA,CACX;AAAA,EACH;AAEAA,YAAAA,YAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA,GAAG,QAAQ,KAAK,IAAI,QAAQ,MAAM,OAAO,QAAQ,IAAI,SAAS;AAAA,EAAA;AAEhE,yBAAuB,SAAS;AAClC;AAEA,SAAS,8BAA8B,WAAkC;AACvE,MAAI,4BAA4B,IAAI,SAAS,GAAG;AAC9C;AAAA,EACF;AAEA,8BAA4B,IAAI,SAAS;AACzC,sBAAoB,MAAM,MAAM;AAC9B,gCAA4B,OAAO,SAAS;AAC5C,2BAAuB,SAAS;AAAA,EAClC,CAAC;AACH;AAEA,SAAS,uBAAuB,WAAkC;AAChE,QAAM,SAAS,gBAAgB,SAAS;AAOxC,MAAI,CAAC,UAAU,CAAC,OAAO,eAAe;AACpC;AAAA,EACF;AAEA,QAAM,cAAc,gBAAgB,MAAM;AAO1C,MAAI;AACJ,MAAI,eAAe,YAAY,iBAAiB;AAC9C,UAAM,YAAY,YAAY,gBAAA;AAC9B,UAAM,UAAW,YAAY,eAAe,WAAW;AAGvD,UAAM,cACJ,OAAO,YAAY,WACf,EAAE,MAAM,SAAS,OAAO,SAAS,KAAK,SAAS,QAAQ,YACvD;AAAA,MACE,MAAM,QAAQ,QAAQ;AAAA,MACtB,OAAO,QAAQ,SAAS;AAAA,MACxB,KAAK,QAAQ,OAAO;AAAA,MACpB,QAAQ,QAAQ,UAAU;AAAA,IAAA;AAElC,sBAAkB;AAAA,MAChB,OAAO,UAAU,QAAQ,YAAY,OAAO,YAAY;AAAA,MACxD,QAAQ,UAAU,SAAS,YAAY,MAAM,YAAY;AAAA,IAAA;AAAA,EAE7D;AAEA,kBAAgB,QAAQ,OAAO,eAAe,eAAe;AAC/D;AAUA,SAAS,yBACP,WACA,gBACA,YACA,eACM;AACN,QAAM,WAAY,UAAU,QAAQ,CAAA;AAGpC,QAAM,sBAAsB;AAG5B,QAAM,mBAAmB,oBAAoB,kBAAA;AAK7C,MAAI,CAAC,YAAY,CAAC,MAAM,QAAQ,QAAQ,GAAG;AACzC;AAAA,EACF;AAGAA,wBAAY,KAAK,eAAe,iBAAiB;AAGjD,QAAM,YAAY,eAAe,aAAa;AAC9C,QAAM,UAAUI,oBAAAA,iBAAiB,eAAe,OAAO;AACvD,QAAM,MAAMC,UAAAA,aAAa,eAAe,GAAG;AAC3C,QAAM,iBAAiB,eAAe,kBAAkB;AAExDL,YAAAA,YAAY,IAAI,UAAU,cAAc,SAAS,cAAc,OAAO;AAKtE,MAAI;AAGJ,QAAM,cAAcM,aAAAA,UAAU,eAAe,KAAK;AAClD,QAAM,oBACJ,YAAY,SAAS,WACpB,YAAY,UAAU,WACpB,YAAY,SAAS,aACpB,YAAY,SAAS,UACrB,YAAY,SAAS;AAE3B,QAAM,QAAQ,oBACVC,aAAAA,YAAY,aAAa,YAAY,OAAO,UAAU,OAAO,eAAe,UAAU,IACtF;AAGJ,QAAM,eAAeD,aAAAA,UAAU,eAAe,MAAM;AACpD,QAAM,qBACJ,aAAa,SAAS,WACrB,YAAY,WAAW,WACrB,aAAa,SAAS,aACrB,aAAa,SAAS,UACtB,aAAa,SAAS;AAE5B,QAAM,SAAS,qBACXC,aAAAA,YAAY,cAAc,YAAY,QAAQ,UAAU,QAAQ,eAAe,QAAQ,IACvF;AAGJ,MAAI,UAAU,UAAa,WAAW,QAAW;AAE/C,UAAM,eACJ,UAAU,SACNC,aAAAA;AAAAA,MACE;AAAA,MACA,eAAe;AAAA,MACf,eAAe;AAAA,MACf,YAAY;AAAA,MACZ,UAAU;AAAA,MACV,eAAe;AAAA,IAAA,IAEhB,UAAU,SAAS;AAC1B,UAAM,gBACJ,WAAW,SACPA,aAAAA;AAAAA,MACE;AAAA,MACA,eAAe;AAAA,MACf,eAAe;AAAA,MACf,YAAY;AAAA,MACZ,UAAU;AAAA,MACV,eAAe;AAAA,IAAA,IAEhB,UAAU,UAAU;AAE3B,2BAAuB;AAAA,MACrB,OAAO;AAAA,MACP,QAAQ;AAAA,IAAA;AAAA,EAEZ;AAIA,QAAM,uBAAuB,uBACzB;AAAA,IACE,OAAO,qBAAqB,QAAQ,QAAQ,OAAO,QAAQ;AAAA,IAC3D,QAAQ,qBAAqB,SAAS,QAAQ,MAAM,QAAQ;AAAA,EAAA,IAE9D;AAEJR,YAAAA,YAAY,IAAI,UAAU,kCAAkC,oBAAoB;AAChFA,YAAAA,YAAY,IAAI,UAAU,sCAAsC,oBAAoB;AAGpF,QAAM,iBAAgC,CAAA;AAEtC,aAAW,SAAS,UAAU;AAE5B,QAAI,CAACS,WAAAA,cAAc,KAAK,GAAG;AACzBT,4BAAY,IAAI,UAAU,8BAA8B;AAAA,QACtD,cAAc,MAAM;AAAA,QACpB,UAAU,MAAM,eAAe;AAAA,QAC/B,eAAe,OAAO,MAAM,oBAAoB;AAAA,MAAA,CACjD;AACD;AAAA,IACF;AACA,UAAM,WAAW,MAAM,eAAe,QAAQ,KAAK;AACnD,QAAI,CAAC,SAAS;AAGZ,YAAM,sBAAsB,uBACxB;AAAA,QACE,OAAO,qBAAqB,QAAQ,QAAQ,OAAO,QAAQ;AAAA,QAC3D,QAAQ,qBAAqB,SAAS,QAAQ,MAAM,QAAQ;AAAA,MAAA,IAE9D,aACE;AAAA,QACE,OAAO,WAAW,SAAS,eAAe,cAAc;AAAA,QACxD,QAAQ,WAAW,UAAU,eAAe,YAAY;AAAA,MAAA,IAE1D;AAENU,iBAAAA;AAAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAAA,MAAA;AAAA,IAEJ;AAIA,UAAM,sBAAsB,uBACxB;AAAA,MACE,OAAO,qBAAqB,QAAQ,QAAQ,OAAO,QAAQ;AAAA,MAC3D,QAAQ,qBAAqB,SAAS,QAAQ,MAAM,QAAQ;AAAA,IAAA,IAE9D,aACE;AAAA,MACE,OAAO,WAAW,SAAS,eAAe,cAAc;AAAA,MACxD,QAAQ,WAAW,UAAU,eAAe,YAAY;AAAA,IAAA,IAE1D;AAEN,UAAM,OAAOC,WAAAA,aAAa,OAAO,qBAAqB,MAAS;AAC/D,UAAM,SAASC,WAAAA,UAAU,KAAK;AAE9B,mBAAe,KAAK,EAAE,OAAO,MAAM,QAAQ;AAAA,EAC7C;AAGA,QAAM,WAAW,WAAW,SAAS;AACrC,MAAI,CAAC,UAAU;AACbZ,cAAAA,YAAY,MAAM,UAAU,sBAAsB,SAAS,EAAE;AAC7D;AAAA,EACF;AAGA,QAAM,iBAAiB;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EAAA;AAIZ,QAAM,UAAU,SAAS,iBAAiB,gBAAgB,cAA+B;AAGzF,QAAM,WAAW,eAAe,YAAY;AAC5C,QAAM,aAAa,aAAa,YAAY,cAAc;AAG1D,QAAM,EAAE,OAAO,gBAAgB,QAAQ,oBAAoBa,oBAAAA;AAAAA,IACzD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe;AAAA,IACf;AAAA,IACA;AAAA,EAAA;AAIF,MAAI,sBAAsB;AAC1B,MAAIC,gCAAgB,cAAc,KAAK,CAAC,YAAY;AAClD,UAAM,cACJ,cAAc,QACV,iBAAiB,QAAQ,OAAO,QAAQ,QACxC,kBAAkB,QAAQ,MAAM,QAAQ;AAG9C,UAAMC,YAAW,cAAc,QAAQ,IAAI,aAAa,IAAI;AAC5D,UAAMC,iBAAgB,eAAe,SAAS,IAAID,aAAY,eAAe,SAAS,KAAK;AAC3F,UAAME,sBAAqB,cAAcD;AAEzC,0BAAsBE,gBAAAA,oBAAoB,gBAAgBD,qBAAoB,SAAS;AAGvF,eAAW,eAAe,qBAAqB;AAC7C,YAAM,QAAQ,YAAY,MAAM;AAChC,YAAM,aACH,OAAO,SAAS,UAAa,MAAM,OAAO,KAC3C,OAAO,eAAe,UACtB,OAAO,cAAc;AACvB,UAAI,YAAY;AAEd,cAAM,gBAAgB,EAAE,GAAG,YAAY,MAAM,cAAA;AAC7C,YAAI,cAAc,OAAO;AACvB,sBAAY,MAAM,gBAAgB;AAAA,YAChC,GAAG,YAAY,MAAM;AAAA,YACrB,OAAO,YAAY,KAAK;AAAA,UAAA;AAAA,QAE5B,OAAO;AACL,sBAAY,MAAM,gBAAgB;AAAA,YAChC,GAAG,YAAY,MAAM;AAAA,YACrB,QAAQ,YAAY,KAAK;AAAA,UAAA;AAAA,QAE7B;AAEAP,mBAAAA;AAAAA,UACE,YAAY;AAAA,UACZ;AAAA,UACA;AAAA,YACE,OAAO;AAAA,YACP,QAAQ;AAAA,UAAA;AAAA,UAEV;AAAA,YACE,YAAY,QAAQ,OAAO,QAAQ;AAAA,YACnC,UAAU,QAAQ,MAAM,QAAQ;AAAA,UAAA;AAAA,QAClC;AAIF,oBAAY,MAAM,gBAAgB;AAAA,MACpC;AAAA,IACF;AAGA,UAAM,iBAAiB,SAAS;AAAA,MAC9B;AAAA,MACA;AAAA,IAAA;AAEF,YAAQ,gBAAgB,eAAe;AACvC,QAAI,cAAc,UAAU;AAC1B,cAAQ,WAAW,eAAe;AAAA,IACpC,WAAW,cAAc,OAAO;AAC9B,cAAQ,YAAY,eAAe;AAAA,IACrC;AAAA,EACF;AAGA,QAAM,cAAc;AAAA,IAClB,OAAO,iBAAiB,QAAQ,OAAO,QAAQ;AAAA,IAC/C,QAAQ,kBAAkB,QAAQ,MAAM,QAAQ;AAAA,EAAA;AAIlD,QAAM,UAAyB;AAAA,IAC7B,GAAG;AAAA,IACH,UAAU;AAAA,IACV;AAAA,IACA,YAAY;AAAA,MACV,OAAO;AAAA,MACP,QAAQ;AAAA,IAAA;AAAA,EACV;AAIF,QAAM,qBAAqB,cAAc,QAAQ,YAAY,QAAQ,YAAY;AAEjF,QAAM,WAAW,cAAc,QAAQ,IAAI,aAAa,IAAI;AAC5D,QAAM,gBACJ,oBAAoB,SAAS,IAAI,YAAY,oBAAoB,SAAS,KAAK;AACjF,QAAM,iBAAiB,qBAAqB,QAAQ,gBAAgB;AAEpE,MAAI,YAAY;AAChB,MAAI,eAAe;AAGnB,MAAI,cAAc,SAAS;AACzB,UAAM,gBAAgBS,kBAAAA;AAAAA,MACpB;AAAA,MACA;AAAA,MACA,oBAAoB;AAAA,IAAA;AAEtB,gBAAY,cAAc;AAC1B,mBAAe,cAAc;AAAA,EAC/B;AAGA,QAAM,aAAa,eAAe,cAAc;AAChD,MAAI,eAAe,aAAa,cAAc,SAAS;AACrD,eAAW,eAAe,qBAAqB;AAC7C,YAAM,SAASP,WAAAA,UAAU,YAAY,KAAK;AAC1C,YAAM,QAAQ,YAAY;AAE1B,UAAI,cAAc,OAAO;AAEvB,cAAM,gBAAgB,YAAY,UAAU,OAAO,OAAO,MAAM,OAAO,UAAU;AACjF,oBAAY,KAAK,SAAS,KAAK,IAAI,GAAG,aAAa;AAGnD,YAAI,MAAM,eAAe;AACvB,gBAAM,iBAAiB,MAAM,cAAc;AAC3C,gBAAM,gBAAgB,EAAE,GAAG,MAAM,eAAe,QAAQ,cAAA;AAGxDF,qBAAAA,uBAAuB,OAAO,iBAAiB;AAAA,YAC7C,OAAO;AAAA,YACP,QAAQ;AAAA,UAAA,CACT;AAGD,gBAAM,gBAAgB,EAAE,GAAG,MAAM,eAAe,QAAQ,eAAA;AAAA,QAC1D;AAAA,MACF,WAAW,cAAc,UAAU;AAEjC,cAAM,eAAe,YAAY,SAAS,OAAO,QAAQ,MAAM,OAAO,SAAS;AAC/E,oBAAY,KAAK,QAAQ,KAAK,IAAI,GAAG,YAAY;AAGjD,YAAI,MAAM,eAAe;AACvB,gBAAM,gBAAgB,MAAM,cAAc;AAC1C,gBAAM,gBAAgB,EAAE,GAAG,MAAM,eAAe,OAAO,aAAA;AAGvDA,qBAAAA,uBAAuB,OAAO,iBAAiB;AAAA,YAC7C,OAAO;AAAA,YACP,QAAQ;AAAA,UAAA,CACT;AAGD,gBAAM,gBAAgB,EAAE,GAAG,MAAM,eAAe,OAAO,cAAA;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,QAAM,YAAwB,CAAA;AAC9B,MAAI,yBAAyB;AAC7B,MAAI,0BAA0B;AAE9B,MAAI,cAAc,kBAAkB,UAAU;AAE5C,UAAM,oBAAoB,cAAc,QAAQ,YAAY,QAAQ,YAAY;AAChF,UAAM,eAAe,cAAc,QAAQ,IAAI,aAAa,IAAI;AAChE,UAAM,QAAS,SAAsD;AAAA,MACnE;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAGF,QAAI,aAAa,gBAAgB;AAC/B,YAAM,QAAA;AAAA,IACR;AAGA,UAAM,iBAAiB,MAAM;AAAA,MAC3B,CAAC,KAAa,SAAqB,MAAM,KAAK;AAAA,MAC9C;AAAA,IAAA;AAEF,UAAM,gBAAgB,cAAc,QAAQ,IAAI,WAAW,IAAI;AAC/D,UAAM,iBAAiB,MAAM,SAAS,KAAK;AAG3C,QACE,cAAc,UACb,eAAe,WAAW,UAAa,eAAe,WAAW,SAClE;AAEA,gCAA0B,iBAAiB,gBAAgB,QAAQ,MAAM,QAAQ;AAAA,IACnF,WACE,cAAc,aACb,eAAe,UAAU,UAAa,eAAe,UAAU,SAChE;AAEA,+BAAyB,iBAAiB,gBAAgB,QAAQ,OAAO,QAAQ;AAAA,IACnF;AAEA,UAAM,qBAAqB,cAAc,QAAQ,YAAY,SAAS,YAAY;AAClF,UAAM,iBAAiB,qBAAqB,iBAAiB;AAG7D,UAAM,eAAe,eAAe,gBAAgB;AACpD,QAAI,cAAc;AAClB,QAAI,mBAAmB;AAEvB,QAAI,iBAAiB,UAAU;AAC7B,oBAAc,iBAAiB;AAAA,IACjC,WAAW,iBAAiB,OAAO;AACjC,oBAAc;AAAA,IAChB,WAAW,iBAAiB,mBAAmB,MAAM,SAAS,GAAG;AAC/D,yBAAmB,kBAAkB,MAAM,SAAS;AAAA,IACtD,WAAW,iBAAiB,gBAAgB;AAC1C,yBAAmB,iBAAiB,MAAM;AAC1C,oBAAc,mBAAmB;AAAA,IACnC;AAGA,eAAW,QAAQ,OAAO;AAExB,UAAI,eAAe,KAAK;AACxB,UAAII,gBAAAA,gBAAgB,KAAK,QAAQ,GAAG;AAClC,cAAMM,iBAAgB,KAAK,SAAS,SAAS,KAAK;AAClD,cAAM,qBAAqB,oBAAoBA;AAC/C,uBAAeF,gBAAAA,oBAAoB,KAAK,UAAU,oBAAoB,SAAS;AAG/E,aAAK,eAAe,aAAa,OAAO,CAAC,KAAa,UAAuB;AAC3E,gBAAM,OAAO,cAAc,QAAQ,MAAM,KAAK,QAAQ,MAAM,KAAK;AACjE,gBAAM,SAASN,WAAAA,UAAU,MAAM,KAAK;AACpC,gBAAM,aACJ,cAAc,SACT,OAAO,QAAQ,MAAM,OAAO,SAAS,MACrC,OAAO,OAAO,MAAM,OAAO,UAAU;AAC5C,iBAAO,MAAM,OAAO;AAAA,QACtB,GAAG,CAAC;AAAA,MACN;AAGA,YAAM,eAAe,KAAK;AAC1B,YAAM,oBAAoB;AAC1B,YAAM,qBAAqB,oBAAoB;AAC/C,YAAM,gBAAgB,KAAK,SAAS,SAAS,KAAK;AAClD,YAAM,gBAAgB,qBAAqB;AAE3C,YAAM,oBAAoBO,kBAAAA;AAAAA,QACxB;AAAA,QACA;AAAA,QACA,KAAK,SAAS;AAAA,MAAA;AAGhB,UAAI,iBAAiB,kBAAkB;AACvC,YAAM,mBAAmB,kBAAkB;AAG3C,eAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,cAAM,QAAQ,aAAa,CAAC;AAC5B,YAAI,CAAC,MAAO;AAEZ,cAAM,SAASP,WAAAA,UAAU,MAAM,KAAK;AAEpC,YAAI;AACJ,YAAI;AAEJ,YAAI,cAAc,OAAO;AAEvB,4BAAkB,OAAO,QAAQ;AACjC,cAAI,QAAQ,OAAO;AAGnB,gBAAM,mBAAmBS,kBAAAA;AAAAA,YACvB;AAAA,YACA,KAAK;AAAA,YACL,MAAM,KAAK;AAAA,YACX,OAAO,OAAO;AAAA,YACd,OAAO,UAAU;AAAA,UAAA;AAEnB,cAAI,QAAQ,MAAM,cAAc;AAEhC,4BAAkB,MAAM,KAAK,SAAS,OAAO,SAAS;AACtD,cAAI,IAAI,aAAa,SAAS,GAAG;AAC/B,8BAAkB,eAAe;AAAA,UACnC;AAAA,QACF,OAAO;AAEL,4BAAkB,OAAO,OAAO;AAChC,cAAI,QAAQ,MAAM;AAGlB,gBAAM,mBAAmBA,kBAAAA;AAAAA,YACvB;AAAA,YACA,KAAK;AAAA,YACL,MAAM,KAAK;AAAA,YACX,OAAO,QAAQ;AAAA,YACf,OAAO,SAAS;AAAA,UAAA;AAElB,cAAI,QAAQ,OAAO,cAAc;AAEjC,4BAAkB,MAAM,KAAK,UAAU,OAAO,UAAU;AACxD,cAAI,IAAI,aAAa,SAAS,GAAG;AAC/B,8BAAkB,eAAe;AAAA,UACnC;AAAA,QACF;AAGA,cAAM,aAAa,oBAAoB,QAAQ,KAAK;AACpD,YAAI,eAAe,IAAI;AACrB,oBAAU,UAAU,IAAI,EAAE,GAAG,EAAA;AAAA,QAC/B;AAAA,MACF;AAGA,qBAAe,KAAK,gBAAgB,gBAAgB;AAAA,IACtD;AAAA,EACF,OAAO;AAEL,QAAI,cAAc;AAElB,aAAS,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;AACnD,YAAM,QAAQ,oBAAoB,CAAC;AACnC,UAAI,CAAC,MAAO;AAEZ,YAAM,SAAS,SAAS,cAAc,OAAO,GAAG,SAAS,WAAW;AAEpE,gBAAU,KAAK,OAAO,QAAQ;AAC9B,oBAAc,OAAO;AAGrB,UAAI,cAAc,WAAW,IAAI,oBAAoB,SAAS,GAAG;AAC/D,uBAAe,WAAW;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAGAC,kBAAAA,oBAAoB,qBAAqB,SAAS;AAGlDC,4CAAyB,WAAW,wBAAwB,uBAAuB;AAGnF,qBAAmB,WAAW,wBAAwB,uBAAuB;AAG7E,oBAAkB,WAAW,gBAAgB,wBAAwB,uBAAuB;AAG5FvB,wBAAY,QAAQ,eAAe,iBAAiB;AAIpD;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAqBO,SAAS,gBACd,WACA,gBACA,YACA,eACM;AACN,mBAAiB,SAAS,WAAW,gBAAgB,YAAY,aAAa;AAChF;;;;;;;"}

package/dist/layout/layout-engine.d.ts

@@ -0,0 +1,140 @@
+import { LayoutProps } from '../core-props';
+import { LayoutContainer } from './types';
+/**
+ * Callback to apply overflow clipping on a container.
+ * Each renderer implements its own clipping mechanism (e.g., stencil buffer, scissor rect).
+ */
+export type ApplyOverflowClip = (container: LayoutContainer, containerProps: LayoutProps & {
+    cornerRadius?: number | {
+        tl?: number;
+        tr?: number;
+        bl?: number;
+        br?: number;
+    };
+}, width: number, height: number) => void;
+/**
+ * Callback invoked after layout dimensions are applied.
+ * Used for renderer-specific post-layout operations (background drawing, hit areas).
+ */
+export type AfterLayoutCallback = (container: LayoutContainer, width: number, height: number) => void;
+/**
+ * Register a renderer-specific overflow clip implementation.
+ * Multiple renderers can each register their own clip; the layout engine
+ * tries each one until a handler accepts the container.
+ * Prefer this over setApplyOverflowClip for multi-renderer setups.
+ */
+export declare function registerApplyOverflowClip(fn: ApplyOverflowClip): void;
+/**
+ * Replace all registered overflow clip handlers with a single one.
+ * For single-renderer setups. Equivalent to clearing the registry and registering one.
+ * @deprecated Prefer registerApplyOverflowClip for multi-renderer safety.
+ */
+export declare function setApplyOverflowClip(fn: ApplyOverflowClip): void;
+/** Inject the renderer-specific after-layout callback (background, hit area). */
+export declare function setAfterLayout(fn: AfterLayoutCallback): void;
+/**
+ * Callback function for deferred layout updates
+ * Executed after all layouts are complete in next frame
+ */
+type DeferredUpdateCallback = () => void;
+/**
+ * Central processor for deferred layout updates
+ * Collects all updates that require final world coordinates or completed parent layouts
+ * Executes them in batch via single requestAnimationFrame for optimal performance
+ *
+ * Use cases:
+ * - Overflow mask positioning (needs world coordinates)
+ * - Scroll position updates (needs final content size)
+ * - Animation initialization (needs final positions)
+ * - Custom effects requiring complete layout
+ * - Gesture hit area updates (needs final layout size)
+ */
+export declare class DeferredLayoutQueue {
+    private static callbacks;
+    private static scheduled;
+    /**
+     * Schedule a callback to execute after current layout pass completes
+     * All callbacks are batched and executed in single requestAnimationFrame
+     * @param callback - Function to execute in next frame
+     */
+    static defer(callback: DeferredUpdateCallback): void;
+    /**
+     * Execute all pending callbacks in batch
+     * Called once per frame via requestAnimationFrame
+     */
+    private static flush;
+}
+/**
+ * Batches layout calculations to reduce redundant recalculations
+ * Prevents multiple calculations of same container within single synchronous call stack
+ * Does NOT defer to next frame - executes immediately after current stack completes
+ *
+ * Benefits:
+ * - Prevents multiple calculations of same container in one update
+ * - Bottom-up execution order prevents redundant parent recalculations
+ * - No visual flickering (executes in same frame)
+ *
+ * Usage:
+ * - VDOM patches: LayoutBatchQueue.schedule() instead of direct calculateLayout()
+ * - Appliers: LayoutBatchQueue.schedule() instead of direct calculateLayout()
+ * - Tests: Set LayoutBatchQueue.synchronous = true for immediate execution
+ */
+export declare class LayoutBatchQueue {
+    private static pending;
+    private static scheduled;
+    /**
+     * Enable synchronous mode for testing
+     * When true, layouts execute immediately instead of batching
+     */
+    static synchronous: boolean;
+    /**
+     * Schedule a layout calculation to execute after current call stack
+     * Uses microtask (Promise) instead of requestAnimationFrame to avoid flickering
+     * If container is already scheduled, updates entry with latest props
+     * @param container - Container to calculate layout for
+     * @param containerProps - Layout props
+     * @param parentSize - Optional parent size for percentage resolution
+     * @param parentPadding - Optional parent padding for fill resolution
+     */
+    static schedule(container: LayoutContainer, containerProps: LayoutProps, parentSize?: {
+        width: number;
+        height: number;
+    }, parentPadding?: {
+        horizontal: number;
+        vertical: number;
+    }): void;
+    /**
+     * Execute all pending layout calculations immediately
+     * Processes in bottom-up order (deepest children first)
+     * This prevents redundant parent recalculations
+     */
+    static flush(): void;
+}
+/**
+ * Calculate layout for a container and its children
+ * Batches layout calculations for optimal performance
+ * Multiple calls within same frame are deduplicated and executed bottom-up
+ * @param container - Phaser container with children
+ * @param containerProps - Layout props of the container
+ * @param parentSize - Optional parent dimensions for percentage resolution
+ * @param parentPadding - Optional parent padding for 'fill' resolution
+ */
+/**
+ * Main entry point for layout calculation.
+ *
+ * @param container - Container node to layout (satisfies LayoutContainer via duck-typing)
+ * @param containerProps - Layout properties
+ * @param parentSize - Parent dimensions for percentage/fill resolution (optional)
+ * @param parentPadding - Parent padding for fill resolution (optional)
+ *
+ * @migration(audit:scene-portal-mount) Phase 2 — LayoutContainer replaces Phaser.GameObjects.Container
+ */
+export declare function calculateLayout(container: LayoutContainer, containerProps: LayoutProps, parentSize?: {
+    width: number;
+    height: number;
+}, parentPadding?: {
+    horizontal: number;
+    vertical: number;
+}): void;
+export {};
+//# sourceMappingURL=layout-engine.d.ts.map

package/dist/layout/layout-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-engine.d.ts","sourceRoot":"","sources":["../../src/layout/layout-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAUhD,OAAO,KAAK,EAAe,eAAe,EAAuC,MAAM,SAAS,CAAA;AAWhG;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,SAAS,EAAE,eAAe,EAC1B,cAAc,EAAE,WAAW,GAAG;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC/E,EACD,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,IAAI,CAAA;AAET;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,IAAI,CAAA;AAqBT;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAErE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAIhE;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,EAAE,EAAE,mBAAmB,GAAG,IAAI,CAE5D;AAED;;;GAGG;AACH,KAAK,sBAAsB,GAAG,MAAM,IAAI,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,SAAS,CAA+B;IACvD,OAAO,CAAC,MAAM,CAAC,SAAS,CAAQ;IAEhC;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAUpD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK;CAgBrB;AAYD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,OAAO,CAA+C;IACrE,OAAO,CAAC,MAAM,CAAC,SAAS,CAAQ;IAEhC;;;OAGG;IACH,MAAM,CAAC,WAAW,UAAQ;IAE1B;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CACb,SAAS,EAAE,eAAe,EAC1B,cAAc,EAAE,WAAW,EAC3B,UAAU,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAC9C,aAAa,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GACvD,IAAI;IAmBP;;;;OAIG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;CAuCrB;AA8xBD;;;;;;;;GAQG;AACH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,eAAe,EAC1B,cAAc,EAAE,WAAW,EAC3B,UAAU,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9C,aAAa,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD,IAAI,CAEN"}