@pibbl/core 0.0.2 → 0.0.3-alpha.109.1

package/dist/lib/layout/wasm/region.js

@@ -0,0 +1,1018 @@
+import { disposeAllocationCheckpoint } from "../allocation-checkpoint-owner.js";
+import { readyLayoutModule } from "./module.js";
+import { GridV2Region } from "../grid-kernel.js";
+import { GLOBAL_STATE } from "../../global-state.js";
+import { signalGraphSnapshot } from "../../signals/graph.js";
+const nativeLayout = true;
+const counters = { activeGridArenas: 0, gridArenaCreates: 0, flowPlacements: 0, gridCellPlacements: 0, gridTrackResolutions: 0, lineFormations: 0, cachedMeasurements: 0, mainPlacements: 0, crossPlacements: 0, solves: 0, measurementSolves: 0, measuredLeaves: 0, nodeReuses: 0, nodeCreates: 0, activeNodes: 0, activeArenas: 0, activeWasmInstances: 0, wasmInstanceCreates: 0, frames: 0, allocationPasses: 0, allocationItemVisits: 0, allocationCacheHits: 0 };
+function snapshotWasmLayoutDiagnostics() {
+  const signals = signalGraphSnapshot();
+  return {
+    ...counters,
+    structureInputInvalidations: signals.structureInputInvalidations,
+    layoutInputInvalidations: signals.layoutInputInvalidations,
+    measurementInputInvalidations: signals.measurementInputInvalidations,
+    paintInputInvalidations: signals.paintInputInvalidations,
+    transformInputInvalidations: signals.transformInputInvalidations,
+    interactionInputInvalidations: signals.interactionInputInvalidations,
+    unknownInputInvalidations: signals.unknownInputInvalidations
+  };
+}
+if (nativeLayout) {
+  Object.defineProperty(globalThis, "__PIBBL_LAYOUT_DIAGNOSTICS__", {
+    configurable: true,
+    value: snapshotWasmLayoutDiagnostics
+  });
+}
+const rootOwners = /* @__PURE__ */ new WeakMap();
+class RootLayoutOwner {
+  constructor(mount) {
+    this.mount = mount;
+    if (mount?.mainTeardowns.closed) throw new Error("Cannot allocate layout for a disposed root.");
+    this.exports = new WebAssembly.Instance(readyLayoutModule()).exports;
+    counters.activeWasmInstances++;
+    counters.wasmInstanceCreates++;
+    if (mount) {
+      this.teardown = () => this.dispose();
+      mount.mainTeardowns.add(this.teardown);
+    }
+  }
+  mount;
+  exports;
+  handles = /* @__PURE__ */ new Map();
+  grids = /* @__PURE__ */ new Set();
+  teardown;
+  get kernel() {
+    if (!this.exports) throw new Error("The root layout instance is disposed.");
+    return this.exports;
+  }
+  createGrid() {
+    const grid = new GridV2Region(this.kernel, () => {
+      if (this.grids.delete(grid)) counters.activeGridArenas--;
+    });
+    this.grids.add(grid);
+    counters.activeGridArenas++;
+    counters.gridArenaCreates++;
+    return grid;
+  }
+  has(handle, generation) {
+    return this.handles.get(handle) === generation && generation !== 0;
+  }
+  create() {
+    const handle = this.kernel.arena_create();
+    const generation = handle ? this.kernel.arena_generation(handle) : 0;
+    if (!handle || !generation) throw new Error("Layout region handle allocation failed.");
+    this.handles.set(handle, generation);
+    counters.activeArenas++;
+    return { handle, generation };
+  }
+  release(handle, generation) {
+    if (!this.has(handle, generation)) return;
+    try {
+      if (this.kernel.arena_dispose(handle, generation) !== 0) throw new Error("Layout region generation is stale.");
+    } catch (error) {
+      this.dispose(error instanceof WebAssembly.RuntimeError);
+      throw error;
+    } finally {
+      if (this.has(handle, generation)) {
+        this.handles.delete(handle);
+        counters.activeArenas--;
+      }
+    }
+  }
+  dispose(trapped = false) {
+    const kernel = this.exports;
+    if (!kernel) return;
+    this.exports = void 0;
+    counters.activeArenas -= this.handles.size;
+    this.handles.clear();
+    counters.activeWasmInstances--;
+    if (this.mount) {
+      if (rootOwners.get(this.mount) === this) rootOwners.delete(this.mount);
+      if (this.teardown) this.mount.mainTeardowns.remove(this.teardown);
+      this.teardown = void 0;
+    }
+    let errors;
+    for (const grid of this.grids) {
+      try {
+        if (trapped) grid.abandon();
+        else grid.dispose();
+      } catch (error) {
+        (errors ??= []).push(error);
+      }
+    }
+    this.grids.clear();
+    if (!trapped) {
+      try {
+        kernel.dispose();
+      } catch (error) {
+        (errors ??= []).push(error);
+      }
+    }
+    if (errors?.length === 1) throw errors[0];
+    if (errors?.length) throw new AggregateError(errors, "Native layout disposal failed.");
+  }
+}
+function acquireRootOwner(mount) {
+  if (!mount) return new RootLayoutOwner();
+  let owner = rootOwners.get(mount);
+  if (!owner) {
+    owner = new RootLayoutOwner(mount);
+    rootOwners.set(mount, owner);
+  }
+  return owner;
+}
+let measurementOwner;
+function withMeasurementLayoutOwner(owner, work) {
+  const previous = measurementOwner;
+  if (owner) measurementOwner = owner;
+  try {
+    return work();
+  } finally {
+    measurementOwner = previous;
+  }
+}
+const intrinsicUnitCode = { none: 0, point: 1, percent: 2 };
+const intrinsicModeCode = {
+  exact: 0,
+  "fit-content": 1,
+  "max-content": 2
+};
+function intrinsicScalar(value, name) {
+  if (value === void 0) return Number.NaN;
+  if (!Number.isFinite(value) || value < 0) throw new RangeError(`Intrinsic ${name} must be finite and nonnegative.`);
+  return value;
+}
+function writeIntrinsicLength(records, offset, length, name) {
+  const code = intrinsicUnitCode[length.unit];
+  if (length.unit === "none") {
+    if (length.value !== void 0) throw new RangeError(`Intrinsic ${name} without a unit must omit its value.`);
+    records[offset] = 0;
+    records[offset + 1] = code;
+    return;
+  }
+  if (length.value === void 0 || !Number.isFinite(length.value) || length.value < 0) {
+    throw new RangeError(`Intrinsic ${name} must be finite and nonnegative.`);
+  }
+  records[offset] = length.value;
+  records[offset + 1] = code;
+}
+function writeIntrinsicMainRecord(records, offset, item, preparing) {
+  if (!Number.isFinite(item.base) || item.base < 0) throw new RangeError("Intrinsic Flex bases must be finite and nonnegative.");
+  records[offset] = item.base;
+  writeIntrinsicLength(records, offset + 1, item.min, "minimum");
+  writeIntrinsicLength(records, offset + 3, item.max, "maximum");
+  if (!item.measured) {
+    if (item.queryMaximum !== void 0) throw new RangeError("Unmeasured intrinsic Flex items cannot retain a query maximum.");
+    records[offset + 8] = 0;
+    records[offset + 9] = 0;
+    return;
+  }
+  if (preparing) {
+    records[offset + 8] = 1;
+    records[offset + 9] = 0;
+    return;
+  }
+  if (item.queryMaximum === void 0 || !(Number.isFinite(item.queryMaximum) || item.queryMaximum === Infinity) || item.queryMaximum < 0) throw new RangeError("Measured intrinsic Flex items require a nonnegative query maximum.");
+  records[offset + 8] = 2;
+  records[offset + 9] = item.queryMaximum;
+}
+function validateIntrinsicQuery(query) {
+  if (!Number.isFinite(query.gap) || query.gap !== 0) throw new RangeError("Staged intrinsic Flex currently requires a zero numeric gap.");
+  if (query.mode === "max-content" ? query.initialAvailable !== void 0 : query.initialAvailable === void 0) throw new RangeError("Intrinsic main query mode and availability do not agree.");
+  const externalOwner = intrinsicScalar(query.externalOwner, "external owner");
+  const initialAvailable = intrinsicScalar(query.initialAvailable, "initial availability");
+  const rootMin = intrinsicScalar(query.rootMin, "root minimum");
+  const rootMax = intrinsicScalar(query.rootMax, "root maximum");
+  if (!Number.isNaN(rootMin) && !Number.isNaN(rootMax) && rootMin > rootMax) throw new RangeError("Intrinsic root minimum must not exceed its maximum.");
+  return { externalOwner, initialAvailable, rootMin, rootMax };
+}
+function intrinsicStatus(status, operation) {
+  if (status === 2) throw new RangeError("Intrinsic minimum must not exceed maximum.");
+  if (status !== 0) throw new Error(`Experimental staged intrinsic Flex ${operation} failed (${status}).`);
+}
+function prepareTransientIntrinsicMainQueries(items, query) {
+  const { externalOwner, initialAvailable, rootMin, rootMax } = validateIntrinsicQuery(query);
+  const owner = acquireRootOwner(measurementOwner);
+  const standalone = measurementOwner === void 0;
+  let handle = 0, generation = 0;
+  try {
+    ({ handle, generation } = owner.create());
+    const pointer = owner.kernel.resize_intrinsic_main(handle, generation, items.length);
+    if (!pointer && items.length) throw new Error("Intrinsic Flex measurement storage allocation failed.");
+    const records = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    for (let index = 0; index < items.length; index++) writeIntrinsicMainRecord(records, index * 10, items[index], true);
+    intrinsicStatus(owner.kernel.prepare_intrinsic_main_queries(handle, generation, externalOwner, initialAvailable, rootMin, rootMax, intrinsicModeCode[query.mode], query.gap), "query preparation");
+    const output = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    const maximums = new Array(items.length);
+    for (let index = 0; index < items.length; index++) {
+      const maximum = output[index * 10 + 9];
+      if (items[index].measured) {
+        if (!(Number.isFinite(maximum) || maximum === Infinity) || maximum < 0) throw new Error("Experimental staged intrinsic Flex query produced an invalid provider maximum.");
+        maximums[index] = maximum;
+      } else {
+        if (maximum !== 0) throw new Error("Experimental staged intrinsic Flex query wrote a numeric item envelope.");
+        maximums[index] = 0;
+      }
+    }
+    counters.solves++;
+    counters.measurementSolves++;
+    return { maximums };
+  } catch (error) {
+    if (error instanceof WebAssembly.RuntimeError) owner.dispose(true);
+    throw error;
+  } finally {
+    try {
+      if (handle) owner.release(handle, generation);
+    } finally {
+      if (standalone) owner.dispose();
+    }
+  }
+}
+function resolveTransientIntrinsicMain(items, query) {
+  return resolveIntrinsicMain(items, query, false);
+}
+function resolveTransientKnownOwnerMain(items, query) {
+  return resolveIntrinsicMain(items, query, true);
+}
+function resolveIntrinsicMain(items, query, normalOwner) {
+  const { externalOwner, initialAvailable, rootMin, rootMax } = validateIntrinsicQuery(query);
+  const owner = acquireRootOwner(measurementOwner);
+  const standalone = measurementOwner === void 0;
+  let handle = 0, generation = 0;
+  try {
+    ({ handle, generation } = owner.create());
+    const pointer = owner.kernel.resize_intrinsic_main(handle, generation, items.length);
+    if (!pointer && items.length) throw new Error("Intrinsic Flex measurement storage allocation failed.");
+    const records = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    for (let index = 0; index < items.length; index++) {
+      const item = items[index], offset = index * 10;
+      writeIntrinsicMainRecord(records, offset, item, false);
+    }
+    const resolve = normalOwner ? owner.kernel.resolve_intrinsic_main_known_owner : owner.kernel.resolve_intrinsic_main;
+    const status = resolve(
+      handle,
+      generation,
+      externalOwner,
+      initialAvailable,
+      rootMin,
+      rootMax,
+      intrinsicModeCode[query.mode],
+      query.gap
+    );
+    intrinsicStatus(status, "resolution");
+    const main = owner.kernel.intrinsic_main_result(handle, generation);
+    const contributionMain = owner.kernel.intrinsic_main_contribution(handle, generation);
+    const autoMarginFreeMain = owner.kernel.intrinsic_main_auto_free(handle, generation);
+    if (!Number.isFinite(main) || main < 0 || !Number.isFinite(contributionMain) || contributionMain < 0 || !Number.isFinite(autoMarginFreeMain) || autoMarginFreeMain < 0) {
+      throw new Error("Experimental staged intrinsic Flex query produced invalid native owner phases.");
+    }
+    const output = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    const targets = new Array(items.length);
+    const effectiveMins = new Array(items.length);
+    const effectiveMaxes = new Array(items.length);
+    for (let index = 0; index < items.length; index++) {
+      const offset = index * 10;
+      const target = output[offset + 5], minimum = output[offset + 6], maximum = output[offset + 7];
+      if (!Number.isFinite(target) || target < 0 || !Number.isFinite(minimum) || minimum < 0 || !(Number.isFinite(maximum) || maximum === Infinity) || maximum < minimum) {
+        throw new Error("Experimental staged intrinsic Flex query produced invalid child bounds.");
+      }
+      targets[index] = target;
+      effectiveMins[index] = minimum;
+      effectiveMaxes[index] = maximum;
+    }
+    counters.solves++;
+    counters.measurementSolves++;
+    return { main, contributionMain, autoMarginFreeMain, targets, effectiveMins, effectiveMaxes };
+  } catch (error) {
+    if (error instanceof WebAssembly.RuntimeError) owner.dispose(true);
+    throw error;
+  } finally {
+    try {
+      if (handle) owner.release(handle, generation);
+    } finally {
+      if (standalone) owner.dispose();
+    }
+  }
+}
+function writeFlexMainInput(records, offset, item) {
+  records[offset] = item.baseMain;
+  records[offset + 1] = item.minMain;
+  records[offset + 2] = item.maxMain;
+  records[offset + 3] = item.paddingMain;
+  records[offset + 4] = item.grow;
+  records[offset + 5] = item.shrink;
+  records[offset + 6] = 0;
+  records[offset + 7] = 0;
+  records[offset + 8] = item.marginMainBefore ?? 0;
+  records[offset + 9] = item.marginMainAfter ?? 0;
+}
+function solveTransientFlexMain(items, main, gap) {
+  if (!Number.isFinite(main) || main < 0 || !Number.isFinite(gap) || gap < 0) {
+    throw new RangeError("Intrinsic Flex main size and gap must be finite and nonnegative.");
+  }
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    if (!Number.isFinite(item.baseMain) || item.baseMain < 0 || !Number.isFinite(item.minMain) || item.minMain < 0 || !(Number.isFinite(item.maxMain) || item.maxMain === Infinity) || item.maxMain < item.minMain || !Number.isFinite(item.paddingMain) || item.paddingMain < 0 || !Number.isFinite(item.grow) || item.grow < 0 || !Number.isFinite(item.shrink) || item.shrink < 0 || !Number.isFinite(item.marginMainBefore ?? 0) || !Number.isFinite(item.marginMainAfter ?? 0)) {
+      throw new RangeError("Intrinsic Flex inputs must contain finite numeric factors, sizes and margins with ordered main bounds.");
+    }
+  }
+  const owner = acquireRootOwner(measurementOwner);
+  const standalone = measurementOwner === void 0;
+  let handle = 0, generation = 0;
+  try {
+    ({ handle, generation } = owner.create());
+    const pointer = owner.kernel.resize(handle, generation, items.length);
+    if (!pointer && items.length) throw new Error("Layout measurement storage allocation failed.");
+    const records = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    for (let index = 0; index < items.length; index++) {
+      writeFlexMainInput(records, index * 10, items[index]);
+    }
+    if (owner.kernel.solve(handle, generation, main, gap) !== 0) {
+      throw new Error("Experimental Flex intrinsic main allocation failed; numeric overflow or no progress.");
+    }
+    const output = new Float64Array(owner.kernel.memory.buffer, pointer, items.length * 10);
+    const results = new Array(items.length);
+    for (let index = 0; index < items.length; index++) results[index] = output[index * 10 + 6];
+    counters.solves++;
+    counters.measurementSolves++;
+    return results;
+  } catch (error) {
+    if (error instanceof WebAssembly.RuntimeError) owner.dispose(true);
+    throw error;
+  } finally {
+    try {
+      if (handle) owner.release(handle, generation);
+    } finally {
+      if (standalone) owner.dispose();
+    }
+  }
+}
+const alignmentCodes = { stretch: 0, "flex-start": 1, "flex-end": 2, center: 3 };
+const flowAlignmentCodes = { start: 0, center: 1, end: 2, stretch: 3 };
+function sameGridTracks(a, b) {
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index++) {
+    const left = a[index], right = b[index];
+    if (left.kind !== right.kind || (left.kind === "fixed" ? left.value : left.factor) !== (right.kind === "fixed" ? right.value : right.factor)) return false;
+  }
+  return true;
+}
+function sameNumbers(a, b) {
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+  return true;
+}
+class LayoutRegion {
+  constructor(mountOwner) {
+    this.mountOwner = mountOwner;
+  }
+  mountOwner;
+  gridV2;
+  flowCache;
+  placeFlow(items, options) {
+    const kernel = this.ensureOwner();
+    const cached = this.flowCache, prior = cached?.options;
+    let equal = prior?.horizontal === options.horizontal && prior.mainBound === options.mainBound && prior.gap === options.gap && prior.lineGap === options.lineGap && prior.wrap === options.wrap && cached.items.length === items.length;
+    if (equal) for (let index = 0; index < items.length; index++) {
+      const a = cached.items[index], b = items[index];
+      if (a.width !== b.width || a.height !== b.height || a.alignment !== b.alignment) {
+        equal = false;
+        break;
+      }
+    }
+    if (equal) return cached.boxes;
+    try {
+      const pointer = kernel.resize_flow(this.handle, this.generation, items.length);
+      if (!pointer && items.length) throw new Error("Flow storage allocation failed.");
+      const records = new Float64Array(kernel.memory.buffer, pointer, items.length * 8);
+      const inputs = new Array(items.length);
+      for (let index = 0; index < items.length; index++) {
+        const item = items[index], offset = index * 8;
+        inputs[index] = { width: item.width, height: item.height, alignment: item.alignment };
+        records[offset] = options.horizontal ? item.width : item.height;
+        records[offset + 1] = options.horizontal ? item.height : item.width;
+        records[offset + 2] = flowAlignmentCodes[item.alignment];
+      }
+      if (kernel.place_flow(this.handle, this.generation, options.mainBound, options.gap, options.lineGap, options.wrap ? 1 : 0) !== 0) throw new RangeError("Native Flow placement produced invalid geometry.");
+      const resolved = new Float64Array(kernel.memory.buffer, pointer, items.length * 8);
+      const boxes = new Array(items.length);
+      for (let index = 0; index < items.length; index++) {
+        const offset = index * 8;
+        boxes[index] = options.horizontal ? { x: resolved[offset + 3], y: resolved[offset + 4], width: resolved[offset], height: resolved[offset + 5] } : { x: resolved[offset + 4], y: resolved[offset + 3], width: resolved[offset + 5], height: resolved[offset] };
+      }
+      this.flowCache = { options: { ...options }, items: inputs, boxes };
+      counters.flowPlacements++;
+      return boxes;
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  gridRevision = 0;
+  gridCells;
+  gridColumns;
+  gridRows;
+  gridV2Columns;
+  gridV2Rows;
+  gridV2ColumnContributions;
+  gridV2RowContributions;
+  gridV2Cells;
+  resolveGridTracks(tracks, options) {
+    const kernel = this.ensureOwner();
+    const cached = options.axis === "columns" ? this.gridColumns : this.gridRows;
+    if (cached && cached.bound === options.bound && cached.gap === options.gap && sameGridTracks(cached.tracks, tracks)) return cached.values;
+    try {
+      const pointer = kernel.resize_grid(this.handle, this.generation, tracks.length, options.axis === "columns" ? 0 : 1);
+      if (!pointer && tracks.length) throw new Error("Grid track storage allocation failed.");
+      const records = new Float64Array(kernel.memory.buffer, pointer, tracks.length * 3);
+      for (let index = 0; index < tracks.length; index++) {
+        const track = tracks[index];
+        records[index * 3] = track.kind === "fixed" ? 0 : track.kind === "percentage" ? 1 : 2;
+        records[index * 3 + 1] = track.kind === "fixed" ? track.value : track.factor;
+      }
+      if (kernel.resolve_grid_tracks(this.handle, this.generation, options.bound, options.gap, options.axis === "columns" ? 0 : 1) !== 0) throw new RangeError("Grid native track resolution produced invalid geometry.");
+      const resolved = new Float64Array(kernel.memory.buffer, pointer, tracks.length * 3);
+      const values = new Array(tracks.length);
+      for (let index = 0; index < tracks.length; index++) values[index] = resolved[index * 3 + 2];
+      const entry = { tracks, bound: options.bound, gap: options.gap, values };
+      if (options.axis === "columns") this.gridColumns = entry;
+      else this.gridRows = entry;
+      this.gridRevision++;
+      counters.gridTrackResolutions++;
+      return values;
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  placeGridCells(cells) {
+    const kernel = this.ensureOwner();
+    const cached = this.gridCells;
+    let equal = cached?.revision === this.gridRevision && cached.cells.length === cells.length;
+    if (equal) for (let index = 0; index < cells.length; index++) {
+      const a = cached.cells[index], b = cells[index];
+      if (a.columnStart !== b.columnStart || a.columnSpan !== b.columnSpan || a.rowStart !== b.rowStart || a.rowSpan !== b.rowSpan) {
+        equal = false;
+        break;
+      }
+    }
+    if (equal) return cached.boxes;
+    try {
+      if (!this.gridColumns || !this.gridRows) throw new Error("Native Grid placement requires both resolved axes.");
+      const pointer = kernel.resize_grid_cells(this.handle, this.generation, cells.length);
+      if (!pointer && cells.length) throw new Error("Grid cell storage allocation failed.");
+      const records = new Float64Array(kernel.memory.buffer, pointer, cells.length * 8);
+      const inputs = new Array(cells.length);
+      for (let index = 0; index < cells.length; index++) {
+        const cell = cells[index], offset = index * 8;
+        inputs[index] = { columnStart: cell.columnStart, columnSpan: cell.columnSpan, rowStart: cell.rowStart, rowSpan: cell.rowSpan };
+        records[offset] = cell.columnStart - 1;
+        records[offset + 1] = cell.columnSpan;
+        records[offset + 2] = cell.rowStart - 1;
+        records[offset + 3] = cell.rowSpan;
+      }
+      if (kernel.place_grid_cells(this.handle, this.generation) !== 0) throw new RangeError("Grid native cell placement produced invalid geometry.");
+      const boxes = new Array(cells.length);
+      for (let index = 0; index < cells.length; index++) {
+        const offset = index * 8;
+        boxes[index] = { x: records[offset + 4], y: records[offset + 5], width: records[offset + 6], height: records[offset + 7] };
+      }
+      this.gridCells = { revision: this.gridRevision, cells: inputs, boxes };
+      counters.gridCellPlacements++;
+      return boxes;
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  /** V2 Grid records remain region-owned so paint-only work reuses native geometry. */
+  resolveGridV2Tracks(records, options) {
+    const cached = options.axis === 0 ? this.gridV2Columns : this.gridV2Rows;
+    if (cached && cached.bound === options.bound && cached.gap === options.gap && sameNumbers(cached.records, records)) return cached.values;
+    try {
+      const values = this.gridV2Region().tracks(records, options.bound, options.gap, options.axis);
+      const entry = { records: records.slice(), bound: options.bound, gap: options.gap, values };
+      if (options.axis === 0) {
+        this.gridV2Columns = entry;
+        this.gridV2ColumnContributions = void 0;
+      } else {
+        this.gridV2Rows = entry;
+        this.gridV2RowContributions = void 0;
+      }
+      this.gridRevision++;
+      counters.gridTrackResolutions++;
+      return values;
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  /** Fresh native track values after Grid contributions; the prior JS snapshot is stale. */
+  snapshotGridV2Tracks(axis) {
+    try {
+      return this.gridV2Region().resolvedTracks(axis);
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  applyGridV2Contributions(records, gap, axis) {
+    const cached = axis === 0 ? this.gridV2ColumnContributions : this.gridV2RowContributions;
+    if (records.length === 0 && !cached) return;
+    if (cached && cached.gap === gap && sameNumbers(cached.records, records)) return;
+    try {
+      const tracks = axis === 0 ? this.gridV2Columns : this.gridV2Rows;
+      if (cached && tracks) this.gridV2Region().tracks(tracks.records, tracks.bound, tracks.gap, axis);
+      this.gridV2Region().contributions(records, gap, axis);
+      const entry = { records: records.slice(), gap };
+      if (axis === 0) this.gridV2ColumnContributions = entry;
+      else this.gridV2RowContributions = entry;
+      this.gridRevision++;
+      counters.gridTrackResolutions++;
+    } catch (error) {
+      this.fail(error);
+    }
+  }
+  placeGridV2Cells(cells, flow, columnGap, rowGap) {
+    const cached = this.gridV2Cells;
+    let equal = cached?.revision === this.gridRevision && cached.flow === flow && cached.columnGap === columnGap && cached.rowGap === rowGap && cached.cells.length === cells.length;
+    if (equal) for (let index = 0; index < cells.length; index++) {
+      const left = cached.cells[index], right = cells[index];
+      if (left.columnStart !== right.columnStart || left.columnSpan !== right.columnSpan || left.rowStart !== right.rowStart || left.rowSpan !== right.rowSpan) {
+        equal = false;
+        break;
+      }
+    }
+    if (equal) return cached.boxes;
+    try {
+      const boxes = this.gridV2Region().cells(cells, flow, columnGap, rowGap);
+      this.gridV2Cells = { revision: this.gridRevision, cells: cells.map((cell) => ({ ...cell })), flow, columnGap, rowGap, boxes };
+      counters.gridCellPlacements++;
+      return boxes;
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  cachedAllocation;
+  layoutOwner;
+  handle = 0;
+  generation = 0;
+  get allocationCache() {
+    return this.layoutOwner && !this.layoutOwner.has(this.handle, this.generation) ? void 0 : this.cachedAllocation;
+  }
+  set allocationCache(value) {
+    this.cachedAllocation = value;
+  }
+  ensureOwner() {
+    if (this.layoutOwner && !this.layoutOwner.has(this.handle, this.generation)) this.dispose();
+    if (!this.layoutOwner) {
+      this.layoutOwner = acquireRootOwner(this.mountOwner);
+      const region = this.layoutOwner.create();
+      this.handle = region.handle;
+      this.generation = region.generation;
+    }
+    return this.layoutOwner.kernel;
+  }
+  /** Region-owned Grid arena; it shares this root's WebAssembly instance. */
+  gridV2Region() {
+    if (!this.gridV2) {
+      this.ensureOwner();
+      this.gridV2 = this.layoutOwner.createGrid();
+    }
+    return this.gridV2;
+  }
+  fail(error) {
+    if (error instanceof WebAssembly.RuntimeError) this.layoutOwner?.dispose(true);
+    this.dispose();
+    throw error;
+  }
+  records = /* @__PURE__ */ new Map();
+  identities = /* @__PURE__ */ new Map();
+  identity(type, key) {
+    let entries = this.identities.get(type);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      this.identities.set(type, entries);
+    }
+    let token = entries.get(key);
+    if (!token) {
+      token = {};
+      entries.set(key, token);
+    }
+    return token;
+  }
+  /** Stable measurement identity without adding an absolute leaf to the native line. */
+  absoluteMeasurementIdentity(type, key) {
+    this.hasAbsoluteMeasurements = true;
+    const absoluteKey = `absolute:${key}`;
+    const existing = this.identities.get(type)?.get(absoluteKey);
+    if (existing) return existing;
+    const token = this.identity(type, absoluteKey);
+    GLOBAL_STATE.renderTransaction?.onFinish((success) => {
+      if (success) return;
+      const entries = this.identities.get(type);
+      if (entries?.get(absoluteKey) !== token) return;
+      entries.delete(absoluteKey);
+      if (entries.size === 0) this.identities.delete(type);
+    });
+    return token;
+  }
+  results = [];
+  main = -1;
+  wrap = false;
+  crossModeKey = "";
+  gap = -1;
+  order = [];
+  mainPlacementKey = "";
+  mainOffsets = [];
+  allocationRevision = 0;
+  crossSize = -1;
+  crossRecords = [];
+  crossResults = [];
+  hasAbsoluteMeasurements = false;
+  intrinsicMeasurements = /* @__PURE__ */ new Map();
+  readPrimitiveMeasurement(token, key) {
+    const entries = this.intrinsicMeasurements.get(token), entry = entries?.get(key);
+    if (entry) {
+      entries.delete(key);
+      entries.set(key, entry);
+    }
+    return entry;
+  }
+  writePrimitiveMeasurement(token, entry) {
+    if (!this.layoutOwner?.has(this.handle, this.generation)) return;
+    let entries = this.intrinsicMeasurements.get(token);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      this.intrinsicMeasurements.set(token, entries);
+    }
+    if (entries.has(entry.key)) {
+      entries.delete(entry.key);
+      counters.cachedMeasurements--;
+    } else if (entries.size >= 3) {
+      entries.delete(entries.keys().next().value);
+      counters.cachedMeasurements--;
+    }
+    entries.set(entry.key, entry);
+    counters.cachedMeasurements++;
+    if (entry.key.startsWith("finite:absolute-size:")) this.hasAbsoluteMeasurements = true;
+  }
+  /** Reuses the region-owned cache without lending native line membership to absolute leaves. */
+  pruneAbsoluteMeasurements(live) {
+    if (live?.size) this.ensureOwner();
+    if (!this.hasAbsoluteMeasurements) return;
+    let retained = false;
+    for (const [token, entries] of this.intrinsicMeasurements) {
+      for (const key of entries.keys()) {
+        if (!key.startsWith("finite:absolute-size:")) continue;
+        if (live?.has(token)) retained = true;
+        else {
+          entries.delete(key);
+          counters.cachedMeasurements--;
+        }
+      }
+      if (entries.size === 0) this.intrinsicMeasurements.delete(token);
+    }
+    for (const [type, entries] of this.identities) {
+      for (const [key, token] of entries) {
+        if (!key.startsWith("absolute:")) continue;
+        if (live?.has(token)) retained = true;
+        else entries.delete(key);
+      }
+      if (entries.size === 0) this.identities.delete(type);
+    }
+    this.hasAbsoluteMeasurements = retained;
+  }
+  measurements = /* @__PURE__ */ new Map();
+  textMaximums;
+  readTextMaximum(token, content, font) {
+    const entry = this.textMaximums?.get(token);
+    return entry?.content === content && entry.font === font ? entry.width : void 0;
+  }
+  writeTextMaximum(token, content, font, width) {
+    const entries = this.textMaximums ??= /* @__PURE__ */ new Map();
+    if (!entries.has(token)) counters.cachedMeasurements++;
+    entries.set(token, { content, font, width });
+  }
+  readMeasurement(token, key) {
+    const entries = this.measurements.get(token), result = entries?.get(key);
+    if (entries && result) {
+      entries.delete(key);
+      entries.set(key, result);
+    }
+    return result;
+  }
+  writeMeasurement(token, key, size) {
+    let entries = this.measurements.get(token);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      this.measurements.set(token, entries);
+    }
+    if (entries.has(key)) {
+      entries.delete(key);
+      counters.cachedMeasurements--;
+    } else if (entries.size >= 2) {
+      entries.delete(entries.keys().next().value);
+      counters.cachedMeasurements--;
+    }
+    entries.set(key, { ...size });
+    counters.cachedMeasurements++;
+  }
+  releaseMeasurements(token) {
+    counters.cachedMeasurements -= this.intrinsicMeasurements.get(token)?.size ?? 0;
+    this.intrinsicMeasurements.delete(token);
+    if (this.textMaximums?.delete(token)) counters.cachedMeasurements--;
+    counters.cachedMeasurements -= this.measurements.get(token)?.size ?? 0;
+    this.measurements.delete(token);
+  }
+  solve(items, main, gap, wrap = false) {
+    try {
+      this.solveRegion(items, main, gap, wrap);
+    } catch (error) {
+      this.fail(error);
+    }
+  }
+  solveRegion(items, main, gap, wrap) {
+    const kernel = this.ensureOwner();
+    let changed = wrap !== this.wrap || main !== this.main || gap !== this.gap || items.length !== this.order.length;
+    const pointer = kernel.resize(this.handle, this.generation, items.length);
+    const view = new Float64Array(kernel.memory.buffer, pointer, items.length * 10);
+    const alive = /* @__PURE__ */ new Set();
+    for (const [i, item] of items.entries()) {
+      const token = item.layoutToken ?? item.receiverToken;
+      alive.add(token);
+      const record = [item.baseMain, item.minMain, item.maxMain, item.paddingMain, item.grow, item.shrink, 0, 0, item.marginMainBefore ?? 0, item.marginMainAfter ?? 0];
+      const previous = this.records.get(token);
+      if (previous) counters.nodeReuses++;
+      else {
+        counters.nodeCreates++;
+        counters.activeNodes++;
+      }
+      if (!previous || record.some((v, n) => v !== previous[n]) || this.order[i] !== token) {
+        writeFlexMainInput(view, i * 10, item);
+        this.records.set(token, record);
+        changed = true;
+      }
+    }
+    for (const token of this.records.keys()) if (!alive.has(token)) {
+      this.records.delete(token);
+      this.releaseMeasurements(token);
+      counters.activeNodes--;
+    }
+    for (const [type, entries] of this.identities) {
+      for (const [key, token] of entries) if (!alive.has(token) && !key.startsWith("absolute:")) entries.delete(key);
+      if (entries.size === 0) this.identities.delete(type);
+    }
+    if (changed) {
+      try {
+        const status = wrap ? kernel.solve_wrap(this.handle, this.generation, main, gap) : kernel.solve(this.handle, this.generation, main, gap);
+        if (status !== 0) throw new Error(`Experimental Flex WASM allocation failed (${status}); numeric overflow or no progress.`);
+        const output = new Float64Array(kernel.memory.buffer, pointer, items.length * 10);
+        this.results = items.map((_, i) => output[i * 10 + 6]);
+      } catch (error) {
+        this.fail(error);
+      }
+      counters.solves++;
+      this.allocationRevision++;
+      if (wrap) counters.lineFormations++;
+      this.wrap = wrap;
+      this.main = main;
+      this.gap = gap;
+      this.order = items.map((i) => i.layoutToken ?? i.receiverToken);
+    }
+    items.forEach((item, i) => {
+      item.targetMain = this.results[i];
+    });
+  }
+  /** Current native source-line membership, never inferred from placements. */
+  firstWrapLineCount() {
+    if (!this.wrap || !this.layoutOwner?.has(this.handle, this.generation)) {
+      return this.fail(new Error("Structural baseline requires a current wrapped allocation."));
+    }
+    const count = this.layoutOwner.kernel.first_wrap_line_count(this.handle, this.generation);
+    if (!Number.isInteger(count) || count < 0 || count > this.order.length || count === 0 !== (this.order.length === 0)) {
+      return this.fail(new Error("Structural baseline native first-line membership is stale or invalid."));
+    }
+    return count;
+  }
+  /** Current native source-line membership, never inferred from placements. */
+  lastWrapLineCount() {
+    if (!this.wrap || !this.layoutOwner?.has(this.handle, this.generation)) {
+      return this.fail(new Error("Structural baseline requires a current wrapped allocation."));
+    }
+    const count = this.layoutOwner.kernel.last_wrap_line_count(this.handle, this.generation);
+    if (!Number.isInteger(count) || count < 0 || count > this.order.length || count === 0 !== (this.order.length === 0)) {
+      return this.fail(new Error("Structural baseline native last-line membership is stale or invalid."));
+    }
+    return count;
+  }
+  mainAutoFlags;
+  mainAutoRevision = 0;
+  placeMain(main, gap, alignment, reverse = false, autoMargins, autoMarginFreeMain) {
+    if (!this.layoutOwner?.has(this.handle, this.generation)) throw new Error("Experimental Flex main placement requires a solved region.");
+    const kernel = this.layoutOwner.kernel;
+    const code = ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly"].indexOf(alignment);
+    if (autoMargins) {
+      const flags = this.mainAutoFlags ??= [];
+      let changed = flags.length !== autoMargins.length * 2;
+      for (let index = 0; index < autoMargins.length; index++) {
+        const before = autoMargins[index].autoMainBefore === true;
+        const after = autoMargins[index].autoMainAfter === true;
+        if (flags[index * 2] !== before || flags[index * 2 + 1] !== after) changed = true;
+        flags[index * 2] = before;
+        flags[index * 2 + 1] = after;
+      }
+      flags.length = autoMargins.length * 2;
+      if (changed) this.mainAutoRevision++;
+    } else if (this.mainAutoFlags?.length) {
+      this.mainAutoFlags.length = 0;
+      this.mainAutoRevision++;
+    }
+    const key = `${this.allocationRevision}:${main}:${gap}:${code}:${reverse ? 1 : 0}:${this.mainAutoRevision}:${autoMarginFreeMain ?? "geometric"}`;
+    if (key !== this.mainPlacementKey) {
+      try {
+        if (autoMargins) {
+          if (autoMargins.length !== this.order.length) throw new Error("Auto margin placement requires a matching allocation.");
+          const autoPointer = kernel.resize_main_auto(this.handle, this.generation, this.order.length);
+          const flags = new Float64Array(kernel.memory.buffer, autoPointer, this.order.length * 2);
+          for (let index = 0; index < autoMargins.length; index++) {
+            flags[index * 2] = autoMargins[index].autoMainBefore ? 1 : 0;
+            flags[index * 2 + 1] = autoMargins[index].autoMainAfter ? 1 : 0;
+          }
+        }
+        const pointer = kernel.resize(this.handle, this.generation, this.order.length);
+        let status;
+        if (autoMargins && autoMarginFreeMain !== void 0) {
+          if (this.wrap) throw new Error("Staged intrinsic margins require a single line.");
+          status = kernel.place_main_auto_staged(this.handle, this.generation, main, gap, code, reverse ? 1 : 0, autoMarginFreeMain);
+        } else if (autoMargins) {
+          status = this.wrap ? kernel.place_wrap_main_auto(this.handle, this.generation, main, gap, code, reverse ? 1 : 0) : kernel.place_main_auto(this.handle, this.generation, main, gap, code, reverse ? 1 : 0);
+        } else {
+          status = this.wrap ? kernel.place_wrap_main(this.handle, this.generation, main, gap, code, reverse ? 1 : 0) : kernel.place_main(this.handle, this.generation, main, gap, code, reverse ? 1 : 0);
+        }
+        if (status !== 0) throw new Error(`Experimental Flex WASM main placement failed (${status}); nonfinite geometry.`);
+        const output = new Float64Array(kernel.memory.buffer, pointer, this.order.length * 10);
+        this.mainOffsets = this.order.map((_, i) => output[i * 10 + 7]);
+        this.mainPlacementKey = key;
+        counters.mainPlacements++;
+      } catch (error) {
+        this.fail(error);
+      }
+    }
+    return this.mainOffsets;
+  }
+  placeCross(items, size, alignment, options) {
+    const wrap = options?.wrap;
+    const reverse = options?.reverse === true;
+    const baseline = options?.baseline === true;
+    const lastBaseline = baseline && options?.lastBaseline === true;
+    if (baseline && reverse && !wrap) throw new Error("Experimental Flex baseline cross reversal requires wrapped line membership.");
+    if (!this.layoutOwner?.has(this.handle, this.generation)) throw new Error("Experimental Flex cross placement requires a solved region.");
+    const kernel = this.layoutOwner.kernel;
+    const records = items.map((item) => {
+      const participant = baseline && item.alignSelf === "auto" && !item.autoCrossBefore && !item.autoCrossAfter;
+      const physicalEdges = baseline && reverse && (participant || item.autoCrossBefore || item.autoCrossAfter);
+      const beforeAuto = physicalEdges ? item.autoCrossAfter : item.autoCrossBefore;
+      const afterAuto = physicalEdges ? item.autoCrossBefore : item.autoCrossAfter;
+      const before = physicalEdges ? item.marginCrossAfter : item.marginCrossBefore;
+      const after = physicalEdges ? item.marginCrossBefore : item.marginCrossAfter;
+      return [
+        item.preferredCross,
+        item.paddingCross,
+        item.minCross,
+        item.maxCross,
+        item.crossAuto ? 1 : 0,
+        alignmentCodes[item.alignSelf === "auto" ? alignment : item.alignSelf] + (beforeAuto ? 4 : 0) + (afterAuto ? 8 : 0) + (participant ? 16 : 0),
+        baseline ? before ?? 0 : 0,
+        baseline ? after ?? 0 : 0,
+        baseline ? item.firstBaseline ?? Number.NaN : before ?? 0,
+        baseline ? 0 : after ?? 0
+      ];
+    });
+    const code = wrap ? ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly", "stretch"].indexOf(wrap.alignContent) : -1;
+    const modeKey = baseline ? `baseline:${lastBaseline ? "last" : "first"}:${this.allocationRevision}:${wrap ? `wrap:${wrap.gap}:${code}:${reverse ? 1 : 0}` : "nowrap"}` : wrap ? `${this.allocationRevision}:${wrap.gap}:${code}:${reverse ? 1 : 0}` : `nowrap:${reverse ? 1 : 0}`;
+    const changed = modeKey !== this.crossModeKey || size !== this.crossSize || records.length !== this.crossRecords.length || records.some((record, i) => record.some((value, j) => value !== this.crossRecords[i]?.[j]));
+    if (changed) {
+      try {
+        const pointer = kernel.resize_cross(this.handle, this.generation, records.length);
+        const input = new Float64Array(kernel.memory.buffer, pointer, records.length * 10);
+        records.forEach((record, i) => input.set(record, i * 10));
+        const status = baseline ? wrap ? lastBaseline ? kernel.place_wrap_last_baseline(this.handle, this.generation, size, wrap.gap, code, reverse ? 1 : 0) : kernel.place_wrap_first_baseline(this.handle, this.generation, size, wrap.gap, code, reverse ? 1 : 0) : lastBaseline ? kernel.place_last_baseline(this.handle, this.generation, size) : kernel.place_first_baseline(this.handle, this.generation, size) : wrap ? kernel.place_wrap_cross(this.handle, this.generation, size, wrap.gap, code, reverse ? 1 : 0) : kernel.place_cross(this.handle, this.generation, size, reverse ? 1 : 0);
+        if (status !== 0) throw new Error(`Experimental Flex WASM cross placement failed (${status}); invalid or nonfinite geometry.`);
+        const output = new Float64Array(kernel.memory.buffer, pointer, records.length * 10);
+        this.crossResults = records.map((_, i) => ({ outerCross: output[i * 10 + 6], offset: output[i * 10 + 7] }));
+        this.crossRecords = records;
+        this.crossSize = size;
+        this.crossModeKey = modeKey;
+        counters.crossPlacements++;
+      } catch (error) {
+        this.fail(error);
+      }
+    }
+    return this.crossResults;
+  }
+  dispose() {
+    disposeAllocationCheckpoint(this);
+    this.gridV2?.dispose();
+    this.gridV2 = void 0;
+    this.hasAbsoluteMeasurements = false;
+    this.flowCache = void 0;
+    this.allocationCache = void 0;
+    this.gridColumns = void 0;
+    this.gridRows = void 0;
+    this.gridCells = void 0;
+    this.gridRevision = 0;
+    const owner = this.layoutOwner, handle = this.handle, generation = this.generation;
+    this.layoutOwner = void 0;
+    this.handle = 0;
+    this.generation = 0;
+    counters.activeNodes -= this.records.size;
+    for (const token of this.measurements.keys()) this.releaseMeasurements(token);
+    for (const token of this.intrinsicMeasurements.keys()) this.releaseMeasurements(token);
+    if (this.textMaximums) for (const token of this.textMaximums.keys()) this.releaseMeasurements(token);
+    this.textMaximums = void 0;
+    this.records.clear();
+    this.identities.clear();
+    this.results = [];
+    this.order = [];
+    this.main = -1;
+    this.gap = -1;
+    this.mainPlacementKey = "";
+    this.mainOffsets = [];
+    this.mainAutoFlags = void 0;
+    this.mainAutoRevision = 0;
+    this.crossRecords = [];
+    this.crossResults = [];
+    this.crossSize = -1;
+    this.crossModeKey = "";
+    this.wrap = false;
+    if (owner) {
+      try {
+        owner.release(handle, generation);
+      } finally {
+        if (!this.mountOwner) owner.dispose();
+      }
+    }
+  }
+}
+const regions = /* @__PURE__ */ new WeakMap();
+const lastFrames = /* @__PURE__ */ new WeakMap();
+function mountedLayoutRegion() {
+  const refs = GLOBAL_STATE.componentRefs;
+  if (!refs) return void 0;
+  const owner = GLOBAL_STATE.currentPibblInstance;
+  const frame = GLOBAL_STATE.frameSnapshot;
+  if (owner && frame && lastFrames.get(owner) !== frame) {
+    lastFrames.set(owner, frame);
+    counters.frames++;
+  }
+  let region = regions.get(refs);
+  if (!region) {
+    region = new LayoutRegion(owner?.interactionRoot ?? owner);
+    regions.set(refs, region);
+    refs.teardowns.add(() => {
+      region.dispose();
+      regions.delete(refs);
+    });
+  }
+  return region;
+}
+function adoptMountedLayoutRegion(region, release) {
+  const refs = GLOBAL_STATE.componentRefs;
+  if (!refs) throw new Error("Prepared layout adoption requires a mounted component.");
+  const previous = regions.get(refs);
+  if (previous === region) return;
+  previous?.dispose();
+  regions.set(refs, region);
+  refs.teardowns.add(() => {
+    if (regions.get(refs) !== region) return;
+    regions.delete(refs);
+    region.dispose();
+    release();
+  });
+}
+function recordWasmMeasurement() {
+  counters.measuredLeaves++;
+}
+function recordWasmAllocationPass() {
+  counters.allocationPasses++;
+}
+function recordWasmAllocationItem() {
+  counters.allocationItemVisits++;
+}
+function recordWasmAllocationCacheHit() {
+  counters.allocationCacheHits++;
+}
+export {
+  LayoutRegion,
+  adoptMountedLayoutRegion,
+  mountedLayoutRegion,
+  nativeLayout,
+  prepareTransientIntrinsicMainQueries,
+  recordWasmAllocationCacheHit,
+  recordWasmAllocationItem,
+  recordWasmAllocationPass,
+  recordWasmMeasurement,
+  resolveTransientIntrinsicMain,
+  resolveTransientKnownOwnerMain,
+  snapshotWasmLayoutDiagnostics,
+  solveTransientFlexMain,
+  withMeasurementLayoutOwner
+};
+//# sourceMappingURL=region.js.map