@pibbl/core 0.0.2 → 0.0.3-alpha.109.1

package/dist/lib/layout/geometry-publication.js

@@ -0,0 +1,244 @@
+import { resolveStagedTargetRootBounds } from "../focus/geometry.js";
+import { PibblPaintEntryKind } from "../events/paint-entry.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import { getLogicalLayoutOrigin } from "./context.js";
+let nextNodeId = 0;
+const nodeIds = /* @__PURE__ */ new WeakMap();
+const EMPTY = Object.freeze({ generation: 0, boxes: Object.freeze([]), changed: Object.freeze([]) });
+const owners = /* @__PURE__ */ new WeakMap();
+const pending = /* @__PURE__ */ new WeakMap();
+function snapshotLayoutGeometry(instance) {
+  return owners.get(instance.interactionRoot ?? instance)?.snapshot ?? EMPTY;
+}
+function beginLayoutGeometry(instance, transaction) {
+  const root = instance.interactionRoot ?? instance;
+  let owner = owners.get(root);
+  if (!owner) {
+    owner = { instances: /* @__PURE__ */ new Map(), snapshot: EMPTY, paint: /* @__PURE__ */ new Map(), targets: /* @__PURE__ */ new Map() };
+    owners.set(root, owner);
+    root.mainTeardowns.add(() => {
+      owners.delete(root);
+      owner.instances.clear();
+      owner.snapshot = EMPTY;
+      owner.paint = /* @__PURE__ */ new Map();
+      owner.targets = /* @__PURE__ */ new Map();
+    });
+  }
+  let roots = pending.get(transaction);
+  if (!roots) {
+    roots = /* @__PURE__ */ new Map();
+    pending.set(transaction, roots);
+  }
+  let instances = roots.get(root);
+  if (!instances) {
+    instances = /* @__PURE__ */ new Map();
+    roots.set(root, instances);
+    const staged = instances, committed = owner;
+    let candidate;
+    let next;
+    let paint;
+    let targets;
+    transaction.onPreflight?.(() => {
+      targets = /* @__PURE__ */ new Map();
+      committed.candidateTargets = targets;
+      for (const target of root.eventRoot.targets) {
+        if (!retiredTargets.get(transaction)?.has(target)) targets.set(target, preparedLayoutTargetBounds(transaction, target));
+      }
+      for (const target of preparedTargets.get(transaction)?.keys() ?? []) {
+        if ((target.owner.interactionRoot ?? target.owner) === root && !retiredTargets.get(transaction)?.has(target)) targets.set(target, preparedLayoutTargetBounds(transaction, target));
+      }
+      next = new Map(committed.instances);
+      paint = new Map(committed.paint);
+      for (const instance2 of staged.keys()) {
+        const entries = [];
+        for (const entry of instance2.paintEntries) {
+          const transform = copyMatrix(entry.transform);
+          const clippingStack = Object.freeze(entry.clippingStack.map((clip) => Object.freeze({
+            ...clip,
+            path: new Path2D(clip.path),
+            transform: copyMatrix(clip.transform)
+          })));
+          entries.push(entry.paintKind === PibblPaintEntryKind.Path ? Object.freeze({ ...entry, path: new Path2D(entry.path), transform, clippingStack }) : Object.freeze({ ...entry, bounds: new Path2D(entry.bounds), transform, clippingStack }));
+        }
+        paint.set(instance2, Object.freeze(entries));
+      }
+      for (const [instance2, boxes2] of staged) next.set(instance2, boxes2);
+      const boxes = [], changed = [];
+      for (const [instance2, entries] of next) {
+        if (instance2.mainTeardowns.closed) {
+          next.delete(instance2);
+          paint.delete(instance2);
+          continue;
+        }
+        const previous = committed.instances.get(instance2);
+        for (const [component, box] of entries) {
+          validate(box);
+          boxes.push(box);
+          const before = previous?.get(component);
+          if (!before || !sameBox(before, box)) changed.push(Object.freeze({ previous: before, current: box }));
+        }
+      }
+      for (const [instance2, entries] of committed.instances) {
+        const current = next.get(instance2);
+        for (const [component, previous] of entries) if (!current?.has(component)) changed.push(Object.freeze({ previous, current: void 0 }));
+      }
+      candidate = Object.freeze({ generation: committed.snapshot.generation + 1, boxes: Object.freeze(boxes), changed: Object.freeze(changed) });
+    });
+    const adopt = () => {
+      if (candidate && next && paint && targets && !root.mainTeardowns.closed) {
+        committed.instances = next;
+        committed.snapshot = candidate;
+        committed.paint = paint;
+        committed.targets = targets;
+      }
+    };
+    if (transaction.onAdopt) transaction.onAdopt(adopt);
+    transaction.onFinish((success) => {
+      if (success && !transaction.onAdopt) adopt();
+      if (!success && transaction.failed !== false) {
+        committed.instances.clear();
+        committed.snapshot = EMPTY;
+        committed.paint = /* @__PURE__ */ new Map();
+        committed.targets = /* @__PURE__ */ new Map();
+      }
+      if (committed.candidateTargets === targets) committed.candidateTargets = void 0;
+      staged.clear();
+      roots.delete(root);
+      if (!roots.size) pending.delete(transaction);
+    });
+  }
+  instances.set(instance, /* @__PURE__ */ new Map());
+}
+function stageLayoutGeometry(component) {
+  const instance = GLOBAL_STATE.currentPibblInstance, transaction = GLOBAL_STATE.renderTransaction;
+  const allocation = GLOBAL_STATE.layoutStack?.at(-1)?.allocation;
+  if (!instance || !transaction || !allocation) return;
+  const entries = pending.get(transaction)?.get(instance.interactionRoot ?? instance)?.get(instance);
+  if (!entries) return;
+  const origin = getLogicalLayoutOrigin();
+  let nodeId = nodeIds.get(component);
+  if (nodeId === void 0) {
+    nodeId = ++nextNodeId;
+    nodeIds.set(component, nodeId);
+  }
+  entries.set(component, Object.freeze({
+    nodeId,
+    width: allocation.width,
+    height: allocation.height,
+    x: origin.x,
+    y: origin.y
+  }));
+}
+function validate(box) {
+  if (!Number.isFinite(box.width) || !Number.isFinite(box.height) || box.width < 0 || box.height < 0 || !Number.isFinite(box.x) || !Number.isFinite(box.y)) throw new Error("Layout geometry publication requires finite logical boxes and origins.");
+}
+function sameBox(a, b) {
+  return a.width === b.width && a.height === b.height && a.x === b.x && a.y === b.y;
+}
+function committedLayoutPaintEntries(instance) {
+  const owner = owners.get(instance.interactionRoot ?? instance);
+  if (!owner) return;
+  return owner.paint.get(instance) ?? [];
+}
+function committedInstanceRootTransform(instance) {
+  const root = instance.eventRoot.rootInstance;
+  if (!root || instance.mainTeardowns.closed) return;
+  let owner = instance;
+  let transform = new DOMMatrix();
+  while (owner !== root) {
+    const parent = owner.parent && GLOBAL_STATE.pibblInstances.get(owner.parent);
+    if (!parent || parent.mainTeardowns.closed) return;
+    const entries = committedLayoutPaintEntries(parent) ?? Array.from(parent.paintEntries);
+    const bridge = entries.find((entry) => (entry.paintKind === PibblPaintEntryKind.NestedInstance || entry.paintKind === PibblPaintEntryKind.Resolver) && entry.instance === owner);
+    if (!bridge) return;
+    transform = bridge.transform.multiply(transform);
+    owner = parent;
+  }
+  return transform;
+}
+function copyMatrix(matrix) {
+  return new DOMMatrix([matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f]);
+}
+function releaseLayoutTargetGeometry(target) {
+  const owner = owners.get(target.owner.interactionRoot ?? target.owner);
+  owner?.targets.delete(target);
+  owner?.candidateTargets?.delete(target);
+  const transaction = GLOBAL_STATE.renderTransaction ?? target.owner.eventRoot.renderTransaction;
+  if (transaction) {
+    stageLayoutTargetRetirement(transaction, target);
+    preparedTargets.get(transaction)?.delete(target);
+    preparedTargetResults.get(transaction)?.delete(target);
+  }
+}
+function committedLayoutTargetBounds(target) {
+  const owner = owners.get(target.owner.interactionRoot ?? target.owner);
+  return owner?.targets;
+}
+const preparedHtml = /* @__PURE__ */ new WeakMap();
+function stageLayoutHtmlGeometry(transaction, region, geometry) {
+  let entries = preparedHtml.get(transaction);
+  if (!entries) {
+    entries = /* @__PURE__ */ new Map();
+    preparedHtml.set(transaction, entries);
+    transaction.onFinish(() => preparedHtml.delete(transaction));
+  }
+  entries.set(region, geometry);
+}
+function preparedLayoutHtmlGeometry(transaction, region) {
+  return preparedHtml.get(transaction)?.get(region);
+}
+const preparedTargets = /* @__PURE__ */ new WeakMap();
+const preparedTargetResults = /* @__PURE__ */ new WeakMap();
+const retiredTargets = /* @__PURE__ */ new WeakMap();
+function stageLayoutTargetRetirement(transaction, target) {
+  let entries = retiredTargets.get(transaction);
+  if (!entries) {
+    entries = /* @__PURE__ */ new Set();
+    retiredTargets.set(transaction, entries);
+    transaction.onFinish(() => retiredTargets.delete(transaction));
+  }
+  entries.add(target);
+}
+function stageLayoutTargetGeometry(transaction, target, geometry) {
+  if (retiredTargets.get(transaction)?.has(target)) return;
+  let entries = preparedTargets.get(transaction);
+  if (!entries) {
+    entries = /* @__PURE__ */ new Map();
+    preparedTargets.set(transaction, entries);
+    transaction.onFinish(() => preparedTargets.delete(transaction));
+  }
+  entries.set(target, geometry);
+}
+function preparedLayoutTargetBounds(transaction, target) {
+  let results = preparedTargetResults.get(transaction);
+  if (!results) {
+    results = /* @__PURE__ */ new Map();
+    preparedTargetResults.set(transaction, results);
+    transaction.onFinish(() => preparedTargetResults.delete(transaction));
+  }
+  if (results.has(target)) return results.get(target);
+  const staged = preparedTargets.get(transaction)?.get(target);
+  const bounds = staged ? resolveStagedTargetRootBounds({
+    ...target,
+    keyboardNavigationBounds: staged.bounds,
+    keyboardNavigationPoints: void 0,
+    paintEntry: { ...target.paintEntry, transform: staged.transform }
+  }) : resolveStagedTargetRootBounds(target);
+  results.set(target, bounds);
+  return bounds;
+}
+export {
+  beginLayoutGeometry,
+  committedInstanceRootTransform,
+  committedLayoutPaintEntries,
+  committedLayoutTargetBounds,
+  preparedLayoutHtmlGeometry,
+  preparedLayoutTargetBounds,
+  releaseLayoutTargetGeometry,
+  snapshotLayoutGeometry,
+  stageLayoutGeometry,
+  stageLayoutHtmlGeometry,
+  stageLayoutTargetGeometry,
+  stageLayoutTargetRetirement
+};
+//# sourceMappingURL=geometry-publication.js.map

package/dist/lib/layout/geometry-publication.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/layout/geometry-publication.ts"],
+  "sourcesContent": ["import type { HtmlFocusRegion } from '../focus/html-focus-region.js';\nimport { resolveStagedTargetRootBounds } from '../focus/geometry.js';\nimport type { PibblEventTargetRegistration } from '../events/registrations.js';\nimport type { LayoutBox } from './types.js';\nimport { PibblPaintEntryKind, type PibblPaintEntry } from '../events/paint-entry.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport { getLogicalLayoutOrigin } from './context.js';\nimport type { PibblComponentRefs, PibblInstance, PibblRenderTransaction } from '../types.js';\n\ninterface GeometryBox {\n  readonly nodeId: number;\n  readonly width: number;\n  readonly height: number;\n  readonly x: number;\n  readonly y: number;\n}\ninterface GeometryChange {\n  readonly previous: GeometryBox | undefined;\n  readonly current: GeometryBox | undefined;\n}\ninterface GeometrySnapshot {\n  readonly generation: number;\n  readonly boxes: readonly GeometryBox[];\n  readonly changed: readonly GeometryChange[];\n}\ntype InstanceGeometry = ReadonlyMap<PibblComponentRefs<any>, GeometryBox>;\ninterface GeometryOwner {\n  instances: Map<PibblInstance, InstanceGeometry>;\n  snapshot: GeometrySnapshot;\n  paint: ReadonlyMap<PibblInstance, readonly PibblPaintEntry[]>;\n  targets: Map<PibblEventTargetRegistration, Readonly<LayoutBox> | undefined>;\n  candidateTargets?: Map<PibblEventTargetRegistration, Readonly<LayoutBox> | undefined>;\n}\nlet nextNodeId = 0;\nconst nodeIds = new WeakMap<PibblComponentRefs<any>, number>();\nconst EMPTY: GeometrySnapshot = Object.freeze({ generation: 0, boxes: Object.freeze([]), changed: Object.freeze([]) });\nconst owners = new WeakMap<PibblInstance, GeometryOwner>();\nconst pending = new WeakMap<PibblRenderTransaction, Map<PibblInstance, Map<PibblInstance, Map<PibblComponentRefs<any>, GeometryBox>>>>();\n\n/** Internal immutable receipt; it never establishes a reactive geometry-to-style edge. */\nexport function snapshotLayoutGeometry(instance: PibblInstance): GeometrySnapshot {\n  return owners.get(instance.interactionRoot ?? instance)?.snapshot ?? EMPTY;\n}\n\n/** Start one instance's staged geometry, preserving clean managed Layer receipts. */\nexport function beginLayoutGeometry(instance: PibblInstance, transaction: PibblRenderTransaction): void {\n  const root = instance.interactionRoot ?? instance;\n  let owner = owners.get(root);\n  if (!owner) {\n    owner = { instances: new Map(), snapshot: EMPTY, paint: new Map(), targets: new Map() };\n    owners.set(root, owner);\n    root.mainTeardowns.add(() => { owners.delete(root); owner!.instances.clear(); owner!.snapshot = EMPTY; owner!.paint = new Map(); owner!.targets = new Map(); });\n  }\n  let roots = pending.get(transaction);\n  if (!roots) { roots = new Map(); pending.set(transaction, roots); }\n  let instances = roots.get(root);\n  if (!instances) {\n    instances = new Map(); roots.set(root, instances);\n    const staged = instances, committed = owner;\n    let candidate: GeometrySnapshot | undefined;\n    let next: Map<PibblInstance, InstanceGeometry> | undefined;\n    let paint: Map<PibblInstance, readonly PibblPaintEntry[]> | undefined;\n    let targets: Map<PibblEventTargetRegistration, Readonly<LayoutBox> | undefined> | undefined;\n    transaction.onPreflight?.(() => {\n      targets = new Map();\n      committed.candidateTargets = targets;\n      for (const target of root.eventRoot.targets) {\n        if (!retiredTargets.get(transaction)?.has(target)) targets.set(target, preparedLayoutTargetBounds(transaction, target));\n      }\n      for (const target of preparedTargets.get(transaction)?.keys() ?? []) {\n        if ((target.owner.interactionRoot ?? target.owner) === root && !retiredTargets.get(transaction)?.has(target)) targets.set(target, preparedLayoutTargetBounds(transaction, target));\n      }\n      next = new Map(committed.instances);\n      paint = new Map(committed.paint);\n      for (const instance of staged.keys()) {\n        const entries: PibblPaintEntry[] = [];\n        for (const entry of instance.paintEntries) {\n          const transform = copyMatrix(entry.transform);\n          const clippingStack = Object.freeze(entry.clippingStack.map(clip => Object.freeze({\n            ...clip, path: new Path2D(clip.path), transform: copyMatrix(clip.transform),\n          })));\n          entries.push(entry.paintKind === PibblPaintEntryKind.Path ?\n            Object.freeze({ ...entry, path: new Path2D(entry.path), transform, clippingStack }) :\n            Object.freeze({ ...entry, bounds: new Path2D(entry.bounds), transform, clippingStack }));\n        }\n        paint.set(instance, Object.freeze(entries));\n      }\n      for (const [instance, boxes] of staged) next.set(instance, boxes);\n      const boxes: GeometryBox[] = [], changed: GeometryChange[] = [];\n      for (const [instance, entries] of next) {\n        if (instance.mainTeardowns.closed) { next.delete(instance); paint.delete(instance); continue; }\n        const previous = committed.instances.get(instance);\n        for (const [component, box] of entries) {\n          validate(box);\n          boxes.push(box);\n          const before = previous?.get(component);\n          if (!before || !sameBox(before, box)) changed.push(Object.freeze({ previous: before, current: box }));\n        }\n      }\n      for (const [instance, entries] of committed.instances) {\n        const current = next.get(instance);\n        for (const [component, previous] of entries) if (!current?.has(component)) changed.push(Object.freeze({ previous, current: undefined }));\n      }\n      candidate = Object.freeze({ generation: committed.snapshot.generation + 1, boxes: Object.freeze(boxes), changed: Object.freeze(changed) });\n    });\n    const adopt = () => {\n      // Preflight performs allocation and validation. Adoption is pointer swaps only.\n      if (candidate && next && paint && targets && !root.mainTeardowns.closed) {\n        committed.instances = next; committed.snapshot = candidate; committed.paint = paint; committed.targets = targets;\n      }\n    };\n    if (transaction.onAdopt) transaction.onAdopt(adopt);\n    transaction.onFinish(success => {\n      if (success && !transaction.onAdopt) adopt();\n      if (!success && transaction.failed !== false) { committed.instances.clear(); committed.snapshot = EMPTY; committed.paint = new Map(); committed.targets = new Map(); }\n      if (committed.candidateTargets === targets) committed.candidateTargets = undefined;\n      staged.clear(); roots!.delete(root);\n      if (!roots!.size) pending.delete(transaction);\n    });\n  }\n  instances.set(instance, new Map());\n}\n\n/** Record the final logical allocation and accumulated layout origin for this generation. */\nexport function stageLayoutGeometry(component: PibblComponentRefs<any>): void {\n  const instance = GLOBAL_STATE.currentPibblInstance, transaction = GLOBAL_STATE.renderTransaction;\n  const allocation = GLOBAL_STATE.layoutStack?.at(-1)?.allocation;\n  if (!instance || !transaction || !allocation) return;\n  const entries = pending.get(transaction)?.get(instance.interactionRoot ?? instance)?.get(instance);\n  if (!entries) return;\n  const origin = getLogicalLayoutOrigin();\n  let nodeId = nodeIds.get(component);\n  if (nodeId === undefined) { nodeId = ++nextNodeId; nodeIds.set(component, nodeId); }\n  entries.set(component, Object.freeze({ nodeId, width: allocation.width, height: allocation.height,\n    x: origin.x, y: origin.y }));\n}\nfunction validate(box: GeometryBox): void {\n  if (!Number.isFinite(box.width) || !Number.isFinite(box.height) || box.width < 0 || box.height < 0 ||\n      !Number.isFinite(box.x) || !Number.isFinite(box.y)) throw new Error('Layout geometry publication requires finite logical boxes and origins.');\n}\nfunction sameBox(a: GeometryBox, b: GeometryBox): boolean {\n  return a.width === b.width && a.height === b.height && a.x === b.x && a.y === b.y;\n}\n\n\n/** Input reads the last successful geometry, never the mutable paint preparation ledger. */\nexport function committedLayoutPaintEntries(instance: PibblInstance): readonly PibblPaintEntry[] | undefined {\n  const owner = owners.get(instance.interactionRoot ?? instance);\n  // Unmanaged test/backend registrations keep their existing immediate semantics.\n  if (!owner) return;\n  return owner.paint.get(instance) ?? [];\n}\n\n/** Composes only committed parent bridges, including clean managed Layers. */\nexport function committedInstanceRootTransform(instance: PibblInstance): DOMMatrix | undefined {\n  const root = instance.eventRoot.rootInstance;\n  if (!root || instance.mainTeardowns.closed) return;\n  let owner = instance;\n  let transform = new DOMMatrix();\n  while (owner !== root) {\n    const parent = owner.parent && GLOBAL_STATE.pibblInstances.get(owner.parent);\n    if (!parent || parent.mainTeardowns.closed) return;\n    const entries = committedLayoutPaintEntries(parent) ?? Array.from(parent.paintEntries);\n    const bridge = entries.find(entry => (entry.paintKind === PibblPaintEntryKind.NestedInstance || entry.paintKind === PibblPaintEntryKind.Resolver) && entry.instance === owner);\n    if (!bridge) return;\n    transform = bridge.transform.multiply(transform);\n    owner = parent;\n  }\n  return transform;\n}\n\nfunction copyMatrix(matrix: DOMMatrix): DOMMatrix {\n  return new DOMMatrix([matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f]);\n}\n\n/** Released registrations cannot be retained by either committed or prepared geometry. */\nexport function releaseLayoutTargetGeometry(target: PibblEventTargetRegistration): void {\n  const owner = owners.get(target.owner.interactionRoot ?? target.owner);\n  owner?.targets.delete(target);\n  owner?.candidateTargets?.delete(target);\n  const transaction = GLOBAL_STATE.renderTransaction ?? target.owner.eventRoot.renderTransaction;\n  if (transaction) {\n    stageLayoutTargetRetirement(transaction, target);\n    preparedTargets.get(transaction)?.delete(target);\n    preparedTargetResults.get(transaction)?.delete(target);\n  }\n}\n\n/** Returns a published target rectangle, including an intentional absent rectangle. */\nexport function committedLayoutTargetBounds(target: PibblEventTargetRegistration): ReadonlyMap<PibblEventTargetRegistration, Readonly<LayoutBox> | undefined> | undefined {\n  const owner = owners.get(target.owner.interactionRoot ?? target.owner);\n  return owner?.targets;\n}\n\n\ninterface PreparedHtmlGeometry { readonly active: boolean; readonly bounds: Readonly<LayoutBox>; }\nconst preparedHtml = new WeakMap<PibblRenderTransaction, Map<HtmlFocusRegion, PreparedHtmlGeometry>>();\n\n/** HTML and focus preflight share one candidate, without mutating the live region. */\nexport function stageLayoutHtmlGeometry(transaction: PibblRenderTransaction, region: HtmlFocusRegion, geometry: PreparedHtmlGeometry): void {\n  let entries = preparedHtml.get(transaction);\n  if (!entries) {\n    entries = new Map(); preparedHtml.set(transaction, entries);\n    transaction.onFinish(() => preparedHtml.delete(transaction));\n  }\n  entries.set(region, geometry);\n}\n\nexport function preparedLayoutHtmlGeometry(transaction: PibblRenderTransaction, region: HtmlFocusRegion): PreparedHtmlGeometry | undefined {\n  return preparedHtml.get(transaction)?.get(region);\n}\n\n\ninterface PreparedTargetGeometry {\n  readonly bounds: Readonly<LayoutBox> | undefined;\n  readonly transform: DOMMatrix;\n}\nconst preparedTargets = new WeakMap<PibblRenderTransaction, Map<PibblEventTargetRegistration, PreparedTargetGeometry>>();\nconst preparedTargetResults = new WeakMap<PibblRenderTransaction, Map<PibblEventTargetRegistration, Readonly<LayoutBox> | undefined>>();\n\nconst retiredTargets = new WeakMap<PibblRenderTransaction, Set<PibblEventTargetRegistration>>();\n\n/** Excludes retiring registrations from the candidate without touching committed ownership. */\nexport function stageLayoutTargetRetirement(transaction: PibblRenderTransaction, target: PibblEventTargetRegistration): void {\n  let entries = retiredTargets.get(transaction);\n  if (!entries) {\n    entries = new Set(); retiredTargets.set(transaction, entries);\n    transaction.onFinish(() => retiredTargets.delete(transaction));\n  }\n  entries.add(target);\n}\n\n/** External renderer targets join geometry preparation without changing live registrations. */\nexport function stageLayoutTargetGeometry(transaction: PibblRenderTransaction, target: PibblEventTargetRegistration, geometry: PreparedTargetGeometry): void {\n  if (retiredTargets.get(transaction)?.has(target)) return;\n  let entries = preparedTargets.get(transaction);\n  if (!entries) {\n    entries = new Map(); preparedTargets.set(transaction, entries);\n    transaction.onFinish(() => preparedTargets.delete(transaction));\n  }\n  entries.set(target, geometry);\n}\n\n/** The shared preflight result used by both the receipt and focus candidates. */\nexport function preparedLayoutTargetBounds(transaction: PibblRenderTransaction, target: PibblEventTargetRegistration): Readonly<LayoutBox> | undefined {\n  let results = preparedTargetResults.get(transaction);\n  if (!results) {\n    results = new Map(); preparedTargetResults.set(transaction, results);\n    transaction.onFinish(() => preparedTargetResults.delete(transaction));\n  }\n  if (results.has(target)) return results.get(target);\n  const staged = preparedTargets.get(transaction)?.get(target);\n  const bounds = staged ? resolveStagedTargetRootBounds({ ...target,\n    keyboardNavigationBounds: staged.bounds, keyboardNavigationPoints: undefined,\n    paintEntry: { ...target.paintEntry, transform: staged.transform } as NonNullable<PibblEventTargetRegistration['paintEntry']>,\n  }) : resolveStagedTargetRootBounds(target);\n  results.set(target, bounds);\n  return bounds;\n}\n"],
+  "mappings": "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",
+  "names": ["instance", "boxes"]
+}

package/dist/lib/layout/grid-kernel.d.ts

@@ -0,0 +1,63 @@
+/** Private v2 Grid WASM protocol. ABI wiring supplies these exports. */
+export interface GridV2Kernel {
+    grid_v2_create(): number;
+    grid_v2_generation(handle: number): number;
+    grid_v2_dispose(handle: number, generation: number): number;
+    grid_v2_resize_tracks(handle: number, generation: number, count: number, axis: number): number;
+    grid_v2_resolve_tracks(handle: number, generation: number, bound: number, gap: number, axis: number): number;
+    grid_v2_resize_contributions(handle: number, generation: number, count: number, axis: number): number;
+    grid_v2_apply_contributions(handle: number, generation: number, gap: number, axis: number): number;
+    grid_v2_resize_cells(handle: number, generation: number, count: number): number;
+    grid_v2_place_cells(handle: number, generation: number, columnsPointer: number, columns: number, rowsPointer: number, rows: number, columnGap: number, rowGap: number): number;
+    grid_v2_assign_cells(handle: number, generation: number, columns: number, rows: number, flow: number): number;
+    grid_v2_assigned_columns(handle: number, generation: number): number;
+    grid_v2_assigned_rows(handle: number, generation: number): number;
+    grid_v2_collapse_auto_fit(handle: number, generation: number, axis: number, explicit: number): number;
+    grid_v2_auto_fit_keep(handle: number, generation: number, index: number, axis: number): number;
+    memory: WebAssembly.Memory;
+}
+export declare const GRID_V2_TRACK_STRIDE = 7;
+export declare const GRID_V2_CELL_STRIDE = 8;
+export interface GridV2Cell {
+    readonly columnStart: number;
+    readonly columnSpan: number;
+    readonly rowStart: number;
+    readonly rowSpan: number;
+}
+export interface GridV2AutoFitCollapse {
+    readonly keep: readonly boolean[];
+    readonly cells: readonly GridV2Cell[];
+}
+export declare class GridV2Region {
+    private readonly kernel;
+    private readonly release?;
+    readonly handle: number;
+    readonly generation: number;
+    private disposed;
+    private readonly pointers;
+    private readonly counts;
+    private cellPointer;
+    private cellCount;
+    constructor(kernel: GridV2Kernel, release?: (() => void) | undefined);
+    dispose(): void;
+    /** A trapped instance cannot safely re-enter Rust, but still releases host ownership. */
+    abandon(): void;
+    tracks(records: readonly number[], bound: number, gap: number, axis: 0 | 1): readonly number[];
+    /** Returns the current resolved values after native contribution passes. */
+    resolvedTracks(axis: 0 | 1): readonly number[];
+    contributions(records: readonly number[], gap: number, axis: 0 | 1): void;
+    assign(cells: readonly GridV2Cell[], columns: number, rows: number, flow: 0 | 1 | 2 | 3): Readonly<{
+        cells: GridV2Cell[];
+        columns: number;
+        rows: number;
+    }>;
+    collapseAutoFit(axis: 0 | 1, explicit: number): GridV2AutoFitCollapse;
+    cells(cells: readonly GridV2Cell[], flow: 0 | 1 | 2 | 3, columnGap: number, rowGap: number): readonly {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+    private writeCells;
+    private readCells;
+}

package/dist/lib/layout/grid-kernel.js

@@ -0,0 +1,168 @@
+const GRID_V2_TRACK_STRIDE = 7;
+const GRID_V2_CELL_STRIDE = 8;
+class GridV2Region {
+  constructor(kernel, release) {
+    this.kernel = kernel;
+    this.release = release;
+    this.handle = kernel.grid_v2_create();
+    this.generation = this.handle ? kernel.grid_v2_generation(this.handle) : 0;
+    if (!this.generation) throw new Error("Grid v2 arena allocation failed");
+  }
+  kernel;
+  release;
+  handle;
+  generation;
+  disposed = false;
+  pointers = [0, 0];
+  counts = [0, 0];
+  cellPointer = 0;
+  cellCount = 0;
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      if (this.kernel.grid_v2_dispose(this.handle, this.generation) !== 0) throw new Error("Grid v2 arena disposal failed");
+    } finally {
+      this.release?.();
+    }
+  }
+  /** A trapped instance cannot safely re-enter Rust, but still releases host ownership. */
+  abandon() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.release?.();
+  }
+  tracks(records, bound, gap, axis) {
+    if (this.disposed || records.length % GRID_V2_TRACK_STRIDE) {
+      throw new RangeError("Invalid Grid v2 track input");
+    }
+    const count = records.length / GRID_V2_TRACK_STRIDE;
+    const pointer = this.kernel.grid_v2_resize_tracks(this.handle, this.generation, count, axis);
+    if (!pointer) throw new RangeError("Grid v2 track storage allocation failed");
+    let values = new Float64Array(this.kernel.memory.buffer, pointer, records.length);
+    values.set(records);
+    if (this.kernel.grid_v2_resolve_tracks(this.handle, this.generation, bound, gap, axis) !== 0) {
+      throw new RangeError("Grid v2 track resolution failed");
+    }
+    values = new Float64Array(this.kernel.memory.buffer, pointer, records.length);
+    this.pointers[axis] = pointer;
+    this.counts[axis] = count;
+    const resolved = new Array(count);
+    for (let index = 0; index < count; index++) {
+      resolved[index] = values[index * GRID_V2_TRACK_STRIDE + 6];
+    }
+    return resolved;
+  }
+  /** Returns the current resolved values after native contribution passes. */
+  resolvedTracks(axis) {
+    if (this.disposed || !this.pointers[axis]) {
+      throw new RangeError("Grid v2 resolved tracks require initialized track storage");
+    }
+    const count = this.counts[axis];
+    const values = new Float64Array(
+      this.kernel.memory.buffer,
+      this.pointers[axis],
+      count * GRID_V2_TRACK_STRIDE
+    );
+    const resolved = new Array(count);
+    for (let index = 0; index < count; index++) {
+      resolved[index] = values[index * GRID_V2_TRACK_STRIDE + 6];
+    }
+    return resolved;
+  }
+  contributions(records, gap, axis) {
+    if (this.disposed || records.length % 4) {
+      throw new RangeError("Invalid Grid intrinsic contribution input");
+    }
+    const pointer = this.kernel.grid_v2_resize_contributions(this.handle, this.generation, records.length / 4, axis);
+    if (!pointer && records.length) throw new RangeError("Grid contribution storage allocation failed");
+    new Float64Array(this.kernel.memory.buffer, pointer, records.length).set(records);
+    if (this.kernel.grid_v2_apply_contributions(this.handle, this.generation, gap, axis) !== 0) {
+      throw new RangeError("Grid contribution resolution failed");
+    }
+  }
+  assign(cells, columns, rows, flow) {
+    const pointer = this.writeCells(cells);
+    if (this.kernel.grid_v2_assign_cells(this.handle, this.generation, columns, rows, flow) !== 0) {
+      throw new RangeError("Grid v2 cell assignment failed");
+    }
+    return {
+      cells: this.readCells(pointer, cells.length),
+      columns: this.kernel.grid_v2_assigned_columns(this.handle, this.generation),
+      rows: this.kernel.grid_v2_assigned_rows(this.handle, this.generation)
+    };
+  }
+  collapseAutoFit(axis, explicit) {
+    if (this.disposed) throw new RangeError("Grid v2 region is disposed");
+    const count = axis === 0 ? this.kernel.grid_v2_assigned_columns(this.handle, this.generation) : this.kernel.grid_v2_assigned_rows(this.handle, this.generation);
+    if (this.kernel.grid_v2_collapse_auto_fit(this.handle, this.generation, axis, explicit) !== 0) {
+      throw new RangeError("Grid auto-fit collapse failed");
+    }
+    const keep = new Array(count);
+    for (let index = 0; index < count; index++) {
+      keep[index] = this.kernel.grid_v2_auto_fit_keep(this.handle, this.generation, index, axis) !== 0;
+    }
+    return { keep, cells: this.readCells(this.cellPointer, this.cellCount) };
+  }
+  cells(cells, flow, columnGap, rowGap) {
+    if (this.disposed || !this.pointers[0] || !this.pointers[1]) {
+      throw new RangeError("Grid v2 cells require resolved tracks");
+    }
+    const pointer = this.writeCells(cells);
+    if (this.kernel.grid_v2_assign_cells(this.handle, this.generation, this.counts[0], this.counts[1], flow) !== 0) {
+      throw new RangeError("Grid v2 cell assignment failed");
+    }
+    if (this.kernel.grid_v2_place_cells(this.handle, this.generation, this.pointers[0], this.counts[0], this.pointers[1], this.counts[1], columnGap, rowGap) !== 0) {
+      throw new RangeError("Grid v2 cell placement failed");
+    }
+    const values = new Float64Array(this.kernel.memory.buffer, pointer, cells.length * GRID_V2_CELL_STRIDE);
+    const placements = new Array(cells.length);
+    for (let index = 0; index < cells.length; index++) {
+      const offset = index * GRID_V2_CELL_STRIDE;
+      placements[index] = {
+        x: values[offset + 4],
+        y: values[offset + 5],
+        width: values[offset + 6],
+        height: values[offset + 7]
+      };
+    }
+    return placements;
+  }
+  writeCells(cells) {
+    if (this.disposed) throw new RangeError("Grid v2 region is disposed");
+    const pointer = this.kernel.grid_v2_resize_cells(this.handle, this.generation, cells.length);
+    if (!pointer && cells.length) throw new RangeError("Grid v2 cell storage allocation failed");
+    const values = new Float64Array(this.kernel.memory.buffer, pointer, cells.length * GRID_V2_CELL_STRIDE);
+    for (let index = 0; index < cells.length; index++) {
+      const cell = cells[index];
+      const offset = index * GRID_V2_CELL_STRIDE;
+      values[offset] = cell.columnStart;
+      values[offset + 1] = cell.columnSpan;
+      values[offset + 2] = cell.rowStart;
+      values[offset + 3] = cell.rowSpan;
+    }
+    this.cellPointer = pointer;
+    this.cellCount = cells.length;
+    return pointer;
+  }
+  readCells(pointer, count) {
+    const values = new Float64Array(this.kernel.memory.buffer, pointer, count * GRID_V2_CELL_STRIDE);
+    const cells = new Array(count);
+    for (let index = 0; index < count; index++) {
+      const offset = index * GRID_V2_CELL_STRIDE;
+      cells[index] = {
+        columnStart: values[offset],
+        columnSpan: values[offset + 1],
+        rowStart: values[offset + 2],
+        rowSpan: values[offset + 3]
+      };
+    }
+    return cells;
+  }
+}
+export {
+  GRID_V2_CELL_STRIDE,
+  GRID_V2_TRACK_STRIDE,
+  GridV2Region
+};
+//# sourceMappingURL=grid-kernel.js.map

package/dist/lib/layout/grid-kernel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/layout/grid-kernel.ts"],
+  "sourcesContent": ["/** Private v2 Grid WASM protocol. ABI wiring supplies these exports. */\nexport interface GridV2Kernel {\n  grid_v2_create(): number;\n  grid_v2_generation(handle: number): number;\n  grid_v2_dispose(handle: number, generation: number): number;\n  grid_v2_resize_tracks(handle: number, generation: number, count: number, axis: number): number;\n  grid_v2_resolve_tracks(handle: number, generation: number, bound: number, gap: number, axis: number): number;\n  grid_v2_resize_contributions(handle: number, generation: number, count: number, axis: number): number;\n  grid_v2_apply_contributions(handle: number, generation: number, gap: number, axis: number): number;\n  grid_v2_resize_cells(handle: number, generation: number, count: number): number;\n  grid_v2_place_cells(handle: number, generation: number, columnsPointer: number, columns: number, rowsPointer: number, rows: number, columnGap: number, rowGap: number): number;\n  grid_v2_assign_cells(handle: number, generation: number, columns: number, rows: number, flow: number): number;\n  grid_v2_assigned_columns(handle: number, generation: number): number;\n  grid_v2_assigned_rows(handle: number, generation: number): number;\n  grid_v2_collapse_auto_fit(handle: number, generation: number, axis: number, explicit: number): number;\n  grid_v2_auto_fit_keep(handle: number, generation: number, index: number, axis: number): number;\n  memory: WebAssembly.Memory;\n}\n\nexport const GRID_V2_TRACK_STRIDE = 7;\nexport const GRID_V2_CELL_STRIDE = 8;\n\nexport interface GridV2Cell {\n  readonly columnStart: number;\n  readonly columnSpan: number;\n  readonly rowStart: number;\n  readonly rowSpan: number;\n}\n\nexport interface GridV2AutoFitCollapse {\n  readonly keep: readonly boolean[];\n  readonly cells: readonly GridV2Cell[];\n}\n\nexport class GridV2Region {\n  readonly handle: number;\n  readonly generation: number;\n  private disposed = false;\n  private readonly pointers = [0, 0];\n  private readonly counts = [0, 0];\n  private cellPointer = 0;\n  private cellCount = 0;\n\n  constructor(private readonly kernel: GridV2Kernel, private readonly release?: () => void) {\n    this.handle = kernel.grid_v2_create();\n    this.generation = this.handle ? kernel.grid_v2_generation(this.handle) : 0;\n    if (!this.generation) throw new Error('Grid v2 arena allocation failed');\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    try {\n      if (this.kernel.grid_v2_dispose(this.handle, this.generation) !== 0) throw new Error('Grid v2 arena disposal failed');\n    } finally { this.release?.(); }\n  }\n\n  /** A trapped instance cannot safely re-enter Rust, but still releases host ownership. */\n  abandon(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.release?.();\n  }\n\n  tracks(records: readonly number[], bound: number, gap: number, axis: 0 | 1): readonly number[] {\n    if (this.disposed || records.length % GRID_V2_TRACK_STRIDE) {\n      throw new RangeError('Invalid Grid v2 track input');\n    }\n    const count = records.length / GRID_V2_TRACK_STRIDE;\n    const pointer = this.kernel.grid_v2_resize_tracks(this.handle, this.generation, count, axis);\n    if (!pointer) throw new RangeError('Grid v2 track storage allocation failed');\n    let values = new Float64Array(this.kernel.memory.buffer, pointer, records.length);\n    values.set(records);\n    if (this.kernel.grid_v2_resolve_tracks(this.handle, this.generation, bound, gap, axis) !== 0) {\n      throw new RangeError('Grid v2 track resolution failed');\n    }\n    values = new Float64Array(this.kernel.memory.buffer, pointer, records.length);\n    this.pointers[axis] = pointer;\n    this.counts[axis] = count;\n    const resolved = new Array<number>(count);\n    for (let index = 0; index < count; index++) {\n      resolved[index] = values[index * GRID_V2_TRACK_STRIDE + 6]!;\n    }\n    return resolved;\n  }\n\n  /** Returns the current resolved values after native contribution passes. */\n  resolvedTracks(axis: 0 | 1): readonly number[] {\n    if (this.disposed || !this.pointers[axis]) {\n      throw new RangeError('Grid v2 resolved tracks require initialized track storage');\n    }\n    const count = this.counts[axis];\n    const values = new Float64Array(\n      this.kernel.memory.buffer,\n      this.pointers[axis],\n      count * GRID_V2_TRACK_STRIDE,\n    );\n    const resolved = new Array<number>(count);\n    for (let index = 0; index < count; index++) {\n      resolved[index] = values[index * GRID_V2_TRACK_STRIDE + 6]!;\n    }\n    return resolved;\n  }\n\n  contributions(records: readonly number[], gap: number, axis: 0 | 1): void {\n    if (this.disposed || records.length % 4) {\n      throw new RangeError('Invalid Grid intrinsic contribution input');\n    }\n    const pointer = this.kernel.grid_v2_resize_contributions(this.handle, this.generation, records.length / 4, axis);\n    if (!pointer && records.length) throw new RangeError('Grid contribution storage allocation failed');\n    new Float64Array(this.kernel.memory.buffer, pointer, records.length).set(records);\n    if (this.kernel.grid_v2_apply_contributions(this.handle, this.generation, gap, axis) !== 0) {\n      throw new RangeError('Grid contribution resolution failed');\n    }\n  }\n\n  assign(cells: readonly GridV2Cell[], columns: number, rows: number, flow: 0 | 1 | 2 | 3): Readonly<{ cells: GridV2Cell[]; columns: number; rows: number }> {\n    const pointer = this.writeCells(cells);\n    if (this.kernel.grid_v2_assign_cells(this.handle, this.generation, columns, rows, flow) !== 0) {\n      throw new RangeError('Grid v2 cell assignment failed');\n    }\n    return {\n      cells: this.readCells(pointer, cells.length),\n      columns: this.kernel.grid_v2_assigned_columns(this.handle, this.generation),\n      rows: this.kernel.grid_v2_assigned_rows(this.handle, this.generation),\n    };\n  }\n\n  collapseAutoFit(axis: 0 | 1, explicit: number): GridV2AutoFitCollapse {\n    if (this.disposed) throw new RangeError('Grid v2 region is disposed');\n    const count = axis === 0\n      ? this.kernel.grid_v2_assigned_columns(this.handle, this.generation)\n      : this.kernel.grid_v2_assigned_rows(this.handle, this.generation);\n    if (this.kernel.grid_v2_collapse_auto_fit(this.handle, this.generation, axis, explicit) !== 0) {\n      throw new RangeError('Grid auto-fit collapse failed');\n    }\n    const keep = new Array<boolean>(count);\n    for (let index = 0; index < count; index++) {\n      keep[index] = this.kernel.grid_v2_auto_fit_keep(this.handle, this.generation, index, axis) !== 0;\n    }\n    return { keep, cells: this.readCells(this.cellPointer, this.cellCount) };\n  }\n\n  cells(cells: readonly GridV2Cell[], flow: 0 | 1 | 2 | 3, columnGap: number, rowGap: number): readonly { x: number; y: number; width: number; height: number }[] {\n    if (this.disposed || !this.pointers[0] || !this.pointers[1]) {\n      throw new RangeError('Grid v2 cells require resolved tracks');\n    }\n    const pointer = this.writeCells(cells);\n    if (this.kernel.grid_v2_assign_cells(this.handle, this.generation, this.counts[0], this.counts[1], flow) !== 0) {\n      throw new RangeError('Grid v2 cell assignment failed');\n    }\n    if (this.kernel.grid_v2_place_cells(this.handle, this.generation, this.pointers[0], this.counts[0], this.pointers[1], this.counts[1], columnGap, rowGap) !== 0) {\n      throw new RangeError('Grid v2 cell placement failed');\n    }\n    const values = new Float64Array(this.kernel.memory.buffer, pointer, cells.length * GRID_V2_CELL_STRIDE);\n    const placements = new Array<{ x: number; y: number; width: number; height: number }>(cells.length);\n    for (let index = 0; index < cells.length; index++) {\n      const offset = index * GRID_V2_CELL_STRIDE;\n      placements[index] = {\n        x: values[offset + 4]!,\n        y: values[offset + 5]!,\n        width: values[offset + 6]!,\n        height: values[offset + 7]!,\n      };\n    }\n    return placements;\n  }\n\n  private writeCells(cells: readonly GridV2Cell[]): number {\n    if (this.disposed) throw new RangeError('Grid v2 region is disposed');\n    const pointer = this.kernel.grid_v2_resize_cells(this.handle, this.generation, cells.length);\n    if (!pointer && cells.length) throw new RangeError('Grid v2 cell storage allocation failed');\n    const values = new Float64Array(this.kernel.memory.buffer, pointer, cells.length * GRID_V2_CELL_STRIDE);\n    for (let index = 0; index < cells.length; index++) {\n      const cell = cells[index]!;\n      const offset = index * GRID_V2_CELL_STRIDE;\n      values[offset] = cell.columnStart;\n      values[offset + 1] = cell.columnSpan;\n      values[offset + 2] = cell.rowStart;\n      values[offset + 3] = cell.rowSpan;\n    }\n    this.cellPointer = pointer;\n    this.cellCount = cells.length;\n    return pointer;\n  }\n\n  private readCells(pointer: number, count: number): GridV2Cell[] {\n    const values = new Float64Array(this.kernel.memory.buffer, pointer, count * GRID_V2_CELL_STRIDE);\n    const cells = new Array<GridV2Cell>(count);\n    for (let index = 0; index < count; index++) {\n      const offset = index * GRID_V2_CELL_STRIDE;\n      cells[index] = {\n        columnStart: values[offset]!,\n        columnSpan: values[offset + 1]!,\n        rowStart: values[offset + 2]!,\n        rowSpan: values[offset + 3]!,\n      };\n    }\n    return cells;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/layout/grid.d.ts

@@ -1,14 +1,67 @@
 import type { PibblElement } from '../element/types.js';
 import { type PibblStructuralEventProps } from '../components/structural-events.js';
+import { type FitContent, type SizingKeyword } from '../style/sizing-length.js';
 import type { BoxStyle, LayoutItemStyle } from '../style/types.js';
 import type { CanvasMeasurementService, PibblNodeInput, MeasureResult } from '../types.js';
 import type { Constraints, LayoutBox } from './types.js';
-/**
- * A fixed logical size, percentage of available space, or fractional share of remaining grid space.
+/** A scalar, fractional, or intrinsic breadth accepted by a Grid track.
  *
- * @see {@link GridStyle}
+ * @see {@link GridTrack}
+ */
+export type GridTrackBreadth = number | `${number}%` | `${number}fr` | SizingKeyword | FitContent | 'auto';
+/** A bounded Grid track whose minimum and maximum are resolved by the Grid owner.
+ *
+ * @see {@link GridTrack}
+ */
+export interface GridMinMaxTrack {
+    /** Identifies the bounded track definition. See {@link GridMinMaxTrack}. */
+    readonly kind: 'minmax';
+    /** Minimum track breadth. See {@link GridTrackBreadth}. */
+    readonly min: GridTrackBreadth;
+    /** Maximum track breadth. See {@link GridTrackBreadth}. */
+    readonly max: GridTrackBreadth;
+}
+/** A repeated {@link GridTrack} list. `auto-fill` and `auto-fit` use the available axis size. */
+export interface GridRepeatTrack {
+    /** Identifies the repetition definition. See {@link GridRepeatTrack}. */
+    readonly kind: 'repeat';
+    /** Fixed count or automatic fill/fit policy. See {@link GridRepeatTrack}. */
+    readonly count: number | 'auto-fill' | 'auto-fit';
+    /** Ordered pattern to repeat. See {@link GridTrack}. */
+    readonly tracks: readonly GridTrack[];
+}
+/** A fixed logical size, percentage, fraction, intrinsic breadth, minmax, or repeat track. See {@link GridTrackBreadth}, {@link GridMinMaxTrack}, {@link GridRepeatTrack}. */
+export type GridTrack = GridTrackBreadth | GridMinMaxTrack | GridRepeatTrack;
+/** Creates an immutable bounded Grid track.
+ * @param options - The minimum and maximum breadths.
+ * @returns An immutable `minmax` track definition.
+ * @see {@link GridTrack}
+ */
+export declare function minmax(options: Readonly<{
+    min: GridTrackBreadth;
+    max: GridTrackBreadth;
+}>): GridMinMaxTrack;
+/** Repeats Grid tracks a fixed number of times.
+ * @param tracks - The track sequence to repeat.
+ * @param options - The repeat count.
+ * @returns An immutable repeated track definition.
+ * @see {@link GridTrack}
+ */
+export declare function repeatTracks(tracks: readonly GridTrack[], options: Readonly<{
+    count: number;
+}>): GridRepeatTrack;
+/** Repeats Grid tracks to fill the available axis.
+ * @param tracks - The track sequence to repeat.
+ * @returns An immutable auto-fill track definition.
+ * @see {@link GridTrack}
+ */
+export declare function autoFillTracks(...tracks: readonly GridTrack[]): GridRepeatTrack;
+/** Repeats Grid tracks to fit occupied cells in the available axis.
+ * @param tracks - The track sequence to repeat.
+ * @returns An immutable auto-fit track definition.
+ * @see {@link GridTrack}
  */
-export type GridTrack = number | `${number}%` | `${number}fr`;
+export declare function autoFitTracks(...tracks: readonly GridTrack[]): GridRepeatTrack;
 type GridAlignment = 'stretch' | 'start' | 'center' | 'end';
 /**
  * Supported geometry and presentation properties for Grid.
@@ -27,6 +80,12 @@ export interface GridStyle extends BoxStyle, LayoutItemStyle {
     justifyItems?: GridAlignment;
     /** Default alignment of children on the cross or block axis. See {@link GridAlignment}. */
     alignItems?: GridAlignment;
+    /** Placement direction and dense-packing policy for automatically placed children. */
+    gridAutoFlow?: 'row' | 'column' | 'row dense' | 'column dense';
+    /** Track used when automatic placement creates an implicit column. */
+    gridAutoColumns?: GridTrack;
+    /** Track used when automatic placement creates an implicit row. */
+    gridAutoRows?: GridTrack;
     /** Spacing between adjacent items. See {@link GridStyle}. */
     gap?: number;
     /** Space between adjacent rows or items on the row axis. See {@link GridStyle}. */