@graphrefly/ts 0.0.0 → 0.0.1

package/dist/solutions/reactive-layout/index.cjs

@@ -0,0 +1,4266 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solutions/reactive-layout/index.ts
+var reactive_layout_exports = {};
+__export(reactive_layout_exports, {
+  BLOCKS_MEASUREMENT_KIND: () => BLOCKS_MEASUREMENT_KIND,
+  CapabilityMeasureAdapter: () => CapabilityMeasureAdapter,
+  CellMeasureAdapter: () => CellMeasureAdapter,
+  IMAGE_SIZE_MEASUREMENT_KIND: () => IMAGE_SIZE_MEASUREMENT_KIND,
+  ImageSizeAdapter: () => ImageSizeAdapter,
+  InjectedMeasureAdapter: () => InjectedMeasureAdapter,
+  PrecomputedMeasureAdapter: () => PrecomputedMeasureAdapter,
+  READINESS_MEASUREMENT_KIND: () => READINESS_MEASUREMENT_KIND,
+  SVG_BOUNDS_MEASUREMENT_KIND: () => SVG_BOUNDS_MEASUREMENT_KIND,
+  SvgBoundsAdapter: () => SvgBoundsAdapter,
+  TEXT_SEGMENTS_MEASUREMENT_KIND: () => TEXT_SEGMENTS_MEASUREMENT_KIND,
+  analyzeAndMeasure: () => analyzeAndMeasure,
+  blockAdaptersProvider: () => blockAdaptersProvider,
+  blockMeasurementProvider: () => blockMeasurementProvider,
+  capabilityTextMeasurements: () => capabilityTextMeasurements,
+  carveTextLineSlots: () => carveTextLineSlots,
+  cellTextMeasurements: () => cellTextMeasurements,
+  circleIntervalForBand: () => circleIntervalForBand,
+  computeBlockFlow: () => computeBlockFlow,
+  computeCharPositions: () => computeCharPositions,
+  computeFlowLines: () => computeFlowLines,
+  computeLineBreaks: () => computeLineBreaks,
+  computeTotalHeight: () => computeTotalHeight,
+  imageSizeMeasurements: () => imageSizeMeasurements,
+  injectedTextMeasurements: () => injectedTextMeasurements,
+  layoutNextLine: () => layoutNextLine,
+  measureBlock: () => measureBlock,
+  measureBlocks: () => measureBlocks,
+  mergeMeasurements: () => mergeMeasurements,
+  precomputedTextMeasurements: () => precomputedTextMeasurements,
+  reactiveBlockLayout: () => reactiveBlockLayout,
+  reactiveFlowLayout: () => reactiveFlowLayout,
+  reactiveLayout: () => reactiveLayout,
+  readinessMeasurements: () => readinessMeasurements,
+  readinessTextMeasurements: () => readinessTextMeasurements,
+  rectIntervalForBand: () => rectIntervalForBand,
+  svgBoundsMeasurements: () => svgBoundsMeasurements,
+  textMeasurementProvider: () => textMeasurementProvider
+});
+module.exports = __toCommonJS(reactive_layout_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+function isInvalidErrorPayload(v) {
+  return v === SENTINEL || typeof v === "boolean";
+}
+function errorPayload(reason, fallback = "error without a valid payload") {
+  return isInvalidErrorPayload(reason) ? new Error(fallback) : reason;
+}
+var TIER_START = 0;
+var TIER_CONTROL = 1;
+var TIER_NOTIFICATION = 2;
+var TIER_VALUE = 3;
+var TIER_SETTLE = 4;
+var TIER_TERMINAL = 5;
+var TIER_TEARDOWN = 6;
+var TIER = {
+  START: TIER_START,
+  PAUSE: TIER_CONTROL,
+  RESUME: TIER_CONTROL,
+  PULL: TIER_CONTROL,
+  DIRTY: TIER_NOTIFICATION,
+  DATA: TIER_VALUE,
+  RESOLVED: TIER_VALUE,
+  INVALIDATE: TIER_SETTLE,
+  COMPLETE: TIER_TERMINAL,
+  ERROR: TIER_TERMINAL,
+  TEARDOWN: TIER_TEARDOWN
+};
+function messageTier(t) {
+  return TIER[t];
+}
+function isDeferredTier(t) {
+  return TIER[t] >= TIER_VALUE;
+}
+function isValueTier(t) {
+  return TIER[t] === TIER_VALUE;
+}
+function isPauseBufferedTier(t) {
+  const tier = TIER[t];
+  return tier === TIER_VALUE || tier === TIER_SETTLE;
+}
+function isTerminal(t) {
+  return TIER[t] === TIER_TERMINAL;
+}
+function isUpAllowed(t) {
+  const tier = TIER[t];
+  return tier !== TIER_VALUE && tier !== TIER_TERMINAL;
+}
+
+// src/ctx/types.ts
+var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
+var CTX_NODE_BINDING = /* @__PURE__ */ Symbol("graphrefly.ctx.nodeBinding");
+function depLatest(ctx, depIndex) {
+  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+
+// src/batch/boundary.ts
+var depth = 0;
+var pendingCores = [];
+var pendingHead = 0;
+function enterWave() {
+  depth++;
+}
+function exitWave() {
+  depth--;
+  if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+function deferRewire(core, apply, options = {}) {
+  core.enqueueBoundaryTask({ apply, batchToken: options.batchToken, isReady: options.isReady });
+  pendingCores.push(core);
+}
+function scheduleBoundaryDrain(core) {
+  for (let i = 0; i < core.boundaryTaskCount(); i++) pendingCores.push(core);
+  if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+function drain() {
+  let escaped = null;
+  while (pendingHead < pendingCores.length) {
+    const core = pendingCores[pendingHead++];
+    const task = core.shiftBoundaryTask();
+    if (task === void 0) continue;
+    if (task.batchToken !== void 0) {
+      const committed = task.batchToken.committed === true;
+      if (!committed) continue;
+    }
+    if (task.isReady !== void 0 && !task.isReady()) {
+      core.unshiftBoundaryTask(task);
+      continue;
+    }
+    depth++;
+    try {
+      task.apply();
+    } catch (e) {
+      if (escaped === null) escaped = { e };
+    } finally {
+      depth--;
+    }
+  }
+  pendingCores.length = 0;
+  pendingHead = 0;
+  if (escaped !== null) throw escaped.e;
+}
+
+// src/batch/batch.ts
+var active = null;
+var boundaryOwner = null;
+function currentBatch() {
+  return active !== null;
+}
+function currentBoundaryBatchToken() {
+  return active ?? boundaryOwner ?? void 0;
+}
+function deferToBatch(target, tier3Wave) {
+  if (active === null) return false;
+  if (!active.deferred.has(target)) active.order.push(target);
+  active.deferred.set(target, tier3Wave);
+  return true;
+}
+function deferAfterBatchForTarget(target, fn) {
+  if (active === null || !active.deferred.has(target)) return false;
+  const owner = active;
+  target.__deferBoundary(() => {
+    if (owner.committed) fn();
+  }, owner);
+  return true;
+}
+
+// src/dispatcher/index.ts
+var PoolTable = class {
+  constructor(kind) {
+    this.kind = kind;
+  }
+  fns = [];
+  free = [];
+  register(fn) {
+    const reused = this.free.pop();
+    if (reused !== void 0) {
+      this.fns[reused] = fn;
+      return reused;
+    }
+    const id = this.fns.length;
+    this.fns.push(fn);
+    return id;
+  }
+  unregister(handleId) {
+    if (this.fns[handleId] === void 0) return;
+    this.fns[handleId] = void 0;
+    this.free.push(handleId);
+  }
+  invoke(handleId, ctx) {
+    this.fns[handleId](ctx);
+  }
+};
+var statKey = (h) => `${h.poolId}:${h.handleId}`;
+var Dispatcher = class {
+  pools = [];
+  syncPoolId;
+  asyncPoolId;
+  // opt-in profile recorder (default OFF → zero overhead, F-PERF).
+  _recording = false;
+  _stats = /* @__PURE__ */ new Map();
+  _totalInvokes = 0;
+  constructor() {
+    this.syncPoolId = this.addPool(new PoolTable("sync"));
+    this.asyncPoolId = this.addPool(new PoolTable("async"));
+  }
+  /** Turn the profile recorder on/off (D39). Off = zero overhead on invoke. */
+  setRecording(on) {
+    this._recording = on;
+  }
+  /** Reset accumulated profiling counters. */
+  clearStats() {
+    this._stats.clear();
+    this._totalInvokes = 0;
+  }
+  /** Read a handle's accumulated counters (undefined if it never ran while recording). */
+  statFor(handle) {
+    return this._stats.get(statKey(handle));
+  }
+  /** Total fn invocations recorded across the dispatcher. */
+  get totalInvokes() {
+    return this._totalInvokes;
+  }
+  addPool(pool) {
+    const id = this.pools.length;
+    this.pools.push(pool);
+    return id;
+  }
+  /** Register a fn in a pool, returning its Handle. Default pool = sync (R-sync-core). */
+  register(fn, pool = "sync") {
+    const poolId = pool === "sync" ? this.syncPoolId : pool === "async" ? this.asyncPoolId : pool;
+    const handleId = this.pools[poolId].register(fn);
+    return { poolId, handleId };
+  }
+  /**
+   * Release a handle (B15): frees the pool slot (closure GC'd, id reusable) and drops any
+   * accumulated profile stat so a reused id never inherits the previous tenant's counters.
+   * Called on rewire fn-swap (node._rewire) — the old handle is dropped before the node
+   * adopts the new one. Idempotent. NOT called on deactivate (a node's handle survives
+   * activate↔deactivate and is reused on reactivation; only a rewire swaps it).
+   */
+  unregister(handle) {
+    this.pools[handle.poolId].unregister(handle.handleId);
+    this._stats.delete(statKey(handle));
+  }
+  /** Uniform sync-void invoke (R-sync-core / R-dispatch-all). */
+  invoke(handle, ctx) {
+    if (!this._recording) {
+      this.pools[handle.poolId].invoke(handle.handleId, ctx);
+      return;
+    }
+    this._totalInvokes++;
+    const t0 = performance.now();
+    try {
+      this.pools[handle.poolId].invoke(handle.handleId, ctx);
+    } finally {
+      const dur = (performance.now() - t0) * 1e6;
+      const key = statKey(handle);
+      const s = this._stats.get(key) ?? {
+        invokes: 0,
+        totalDurationNs: 0,
+        lastDurationNs: 0
+      };
+      s.invokes++;
+      s.lastDurationNs = dur;
+      s.totalDurationNs += dur;
+      this._stats.set(key, s);
+    }
+  }
+  poolKind(poolId) {
+    return this.pools[poolId].kind;
+  }
+};
+var defaultDispatcher = new Dispatcher();
+
+// src/graph/environment.ts
+var EnvironmentDrivers = class _EnvironmentDrivers {
+  process;
+  http;
+  sse;
+  websocket;
+  webhook;
+  constructor(init = {}) {
+    this.process = init.process;
+    this.http = init.http;
+    this.sse = init.sse;
+    this.websocket = init.websocket;
+    this.webhook = init.webhook;
+    Object.freeze(this);
+  }
+  static empty() {
+    return EMPTY_ENVIRONMENT;
+  }
+  withProcess(driver) {
+    return new _EnvironmentDrivers({ ...this, process: driver });
+  }
+  withHttp(driver) {
+    return new _EnvironmentDrivers({ ...this, http: driver });
+  }
+  withSse(driver) {
+    return new _EnvironmentDrivers({ ...this, sse: driver });
+  }
+  withWebSocket(driver) {
+    return new _EnvironmentDrivers({ ...this, websocket: driver });
+  }
+  withWebhook(driver) {
+    return new _EnvironmentDrivers({ ...this, webhook: driver });
+  }
+  processDriver() {
+    return this.process;
+  }
+  httpDriver() {
+    return this.http;
+  }
+  sseDriver() {
+    return this.sse;
+  }
+  webSocketDriver() {
+    return this.websocket;
+  }
+  webhookDriver() {
+    return this.webhook;
+  }
+};
+var EMPTY_ENVIRONMENT = new EnvironmentDrivers();
+
+// src/node/core.ts
+var NodeCore = class {
+  nextId = 0;
+  slots = [];
+  values = [];
+  waves = [];
+  controls = [];
+  lifecycles = [];
+  depStates = [];
+  privateStates = [];
+  hooks = [];
+  syncCtxs = [];
+  versionStates = [];
+  boundary = { queue: [], head: 0 };
+  createSlot(slot, state) {
+    const id = this.nextId++;
+    const full = { ...slot, id };
+    this.slots[id] = full;
+    this.depStates[id] = state.dep;
+    this.lifecycles[id] = state.lifecycle;
+    this.values[id] = state.value;
+    this.waves[id] = state.wave;
+    this.controls[id] = state.control;
+    this.privateStates[id] = state.privateState;
+    this.hooks[id] = state.hooks;
+    this.syncCtxs[id] = state.syncCtx;
+    this.versionStates[id] = state.version;
+    return { id, slot: full };
+  }
+  get(id) {
+    const slot = this.slots[id];
+    if (slot === void 0) throw new Error("NodeCore: unknown node slot");
+    return slot;
+  }
+  getValue(id) {
+    const value = this.values[id];
+    if (value === void 0) throw new Error("NodeCore: unknown node value state");
+    return value;
+  }
+  getWave(id) {
+    const wave = this.waves[id];
+    if (wave === void 0) throw new Error("NodeCore: unknown node wave state");
+    return wave;
+  }
+  getControl(id) {
+    const control = this.controls[id];
+    if (control === void 0) throw new Error("NodeCore: unknown node control state");
+    return control;
+  }
+  getLifecycle(id) {
+    const lifecycle = this.lifecycles[id];
+    if (lifecycle === void 0) throw new Error("NodeCore: unknown node lifecycle state");
+    return lifecycle;
+  }
+  getDep(id) {
+    const dep = this.depStates[id];
+    if (dep === void 0) throw new Error("NodeCore: unknown node dep state");
+    return dep;
+  }
+  getPrivateState(id) {
+    const state = this.privateStates[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node private state");
+    return state;
+  }
+  getHooks(id) {
+    const hooks = this.hooks[id];
+    if (hooks === void 0) throw new Error("NodeCore: unknown node cleanup hooks");
+    return hooks;
+  }
+  getSyncCtx(id) {
+    const state = this.syncCtxs[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node ctx state");
+    return state;
+  }
+  getVersion(id) {
+    const state = this.versionStates[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node version state");
+    return state;
+  }
+  /** @internal D122: release graph-owned ephemeral node runtime state from core retention. */
+  releaseSlot(id) {
+    this.slots[id] = void 0;
+    this.depStates[id] = void 0;
+    this.lifecycles[id] = void 0;
+    this.values[id] = void 0;
+    this.waves[id] = void 0;
+    this.controls[id] = void 0;
+    this.privateStates[id] = void 0;
+    this.hooks[id] = void 0;
+    this.syncCtxs[id] = void 0;
+    this.versionStates[id] = void 0;
+  }
+  /** @internal B49: graph-local deferred-boundary queue (rewireNext/upNext/batch-after-commit). */
+  enqueueBoundaryTask(task) {
+    this.boundary.queue.push(task);
+  }
+  /** @internal */
+  hasBoundaryTasks() {
+    return this.boundary.head < this.boundary.queue.length;
+  }
+  /** @internal */
+  boundaryTaskCount() {
+    return this.boundary.queue.length - this.boundary.head;
+  }
+  /** @internal */
+  shiftBoundaryTask() {
+    if (!this.hasBoundaryTasks()) {
+      this.boundary.queue = [];
+      this.boundary.head = 0;
+      return void 0;
+    }
+    const task = this.boundary.queue[this.boundary.head++];
+    if (!this.hasBoundaryTasks()) {
+      this.boundary.queue = [];
+      this.boundary.head = 0;
+    }
+    return task;
+  }
+  /** @internal Put a not-yet-ready task back at this core's FIFO head. */
+  unshiftBoundaryTask(task) {
+    const remaining = this.boundary.queue.slice(this.boundary.head);
+    this.boundary.queue = [task, ...remaining];
+    this.boundary.head = 0;
+  }
+  /** @internal D110: discard all pending tasks caused by an uncommitted batch. */
+  dropBoundaryTasksForBatch(batchToken) {
+    const remaining = this.boundary.queue.slice(this.boundary.head).filter((task) => task.batchToken !== batchToken);
+    this.boundary.queue = remaining;
+    this.boundary.head = 0;
+  }
+};
+function makeDepBookkeeping(depCount) {
+  return {
+    batch: new Array(depCount).fill(null),
+    waveData: Array.from({ length: depCount }, () => []),
+    waveTokens: new Array(depCount).fill(void 0),
+    prev: new Array(depCount).fill(SENTINEL),
+    hasData: new Array(depCount).fill(false),
+    dirty: new Array(depCount).fill(false),
+    tier: new Array(depCount).fill(0),
+    terminal: new Array(depCount).fill(void 0),
+    terminalInput: new Array(depCount).fill(void 0),
+    unsubs: [],
+    idxBoxes: []
+  };
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+function strictCanonicalJsonBytes(value) {
+  return strictJsonCodec.encode(value);
+}
+
+// src/node/versioning.ts
+var ABSENT_V1_SEED = Object.freeze({
+  "@graphrefly/node-version": "v1-absent"
+});
+function fnv1a64(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (const byte of input) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function defaultNodeVersionHash(bytes) {
+  return `fnv1a64:${fnv1a64(bytes)}`;
+}
+function computeV1Cid(policy, value) {
+  return policy.hash(strictCanonicalJsonBytes(value));
+}
+function assertNodeVersionDataCompatible(policy, value) {
+  if (!policy.enabled || policy.level === 0) return;
+  strictCanonicalJsonBytes(value);
+}
+function snapshotNodeVersionData(policy, value) {
+  if (!policy.enabled || policy.level === 0) return value;
+  const bytes = strictCanonicalJsonBytes(value);
+  return strictJsonCodec.decode(bytes);
+}
+function resolveNodeVersioningPolicy(policy) {
+  if (policy === false) return { enabled: false };
+  if (policy === void 0 || policy === 0) return { enabled: true, level: 0 };
+  if (policy === 1) return { enabled: true, level: 1, hash: defaultNodeVersionHash };
+  if (typeof policy === "object" && policy !== null) {
+    if (policy.level === 0) return { enabled: true, level: 0 };
+    if (policy.level === 1) {
+      return { enabled: true, level: 1, hash: policy.hash ?? defaultNodeVersionHash };
+    }
+  }
+  throw new Error("node: versioning level must be 0 or 1; V2/V3 are not locked yet (D109)");
+}
+function createNodeVersion(policy, initialValue = ABSENT_V1_SEED) {
+  if (!policy.enabled) return void 0;
+  if (policy.level === 0) return Object.freeze({ level: 0, counter: 0 });
+  return Object.freeze({
+    level: 1,
+    counter: 0,
+    cid: computeV1Cid(policy, initialValue),
+    prev: null
+  });
+}
+function advanceNodeVersion(current, policy, value) {
+  if (!policy.enabled) return void 0;
+  if (current === void 0) return createNodeVersion(policy, value);
+  if (policy.level === 0) {
+    return Object.freeze({ level: 0, counter: current.counter + 1 });
+  }
+  const previous = current.level === 1 ? current.cid : null;
+  return Object.freeze({
+    level: 1,
+    counter: current.counter + 1,
+    cid: computeV1Cid(policy, value),
+    prev: previous
+  });
+}
+function cloneNodeVersion(version) {
+  if (version === void 0) return void 0;
+  if (version.level === 0) return Object.freeze({ level: 0, counter: version.counter });
+  return Object.freeze({
+    level: 1,
+    counter: version.counter,
+    cid: version.cid,
+    prev: version.prev
+  });
+}
+function restoredV1Cid(policy, hasData, cache) {
+  return computeV1Cid(policy, hasData ? cache : ABSENT_V1_SEED);
+}
+
+// src/node/node.ts
+var constructingCore;
+var constructingEnvironment;
+var ownerTokens = /* @__PURE__ */ new WeakMap();
+var topologyDepsChangedObservers = /* @__PURE__ */ new WeakMap();
+var checkpointReaders = /* @__PURE__ */ new WeakMap();
+var restoreWriters = /* @__PURE__ */ new WeakMap();
+var runtimeReleasers = /* @__PURE__ */ new WeakMap();
+var runtimeQuiescenceReaders = /* @__PURE__ */ new WeakMap();
+var subscriberCountReaders = /* @__PURE__ */ new WeakMap();
+var activationReaders = /* @__PURE__ */ new WeakMap();
+var releasedNodes = /* @__PURE__ */ new WeakSet();
+function withNodeCore(core, create) {
+  const prev = constructingCore;
+  constructingCore = core;
+  try {
+    return create();
+  } finally {
+    constructingCore = prev;
+  }
+}
+function withEnvironmentDrivers(environment, create) {
+  const prev = constructingEnvironment;
+  constructingEnvironment = environment;
+  try {
+    return create();
+  } finally {
+    constructingEnvironment = prev;
+  }
+}
+function getNodeOwner(n) {
+  return ownerTokens.get(n);
+}
+function notifyTopologyDepsChanged(node, prevDeps, deps) {
+  topologyDepsChangedObservers.get(node)?.(node, prevDeps, deps);
+}
+function terminalView(t) {
+  return t === void 0 ? false : t;
+}
+function normalizePullDemand(demand) {
+  if (typeof demand !== "object" || demand === null || Array.isArray(demand)) {
+    throw new Error("ctx.up: PULL requires { pullId, params? } demand payload (D269)");
+  }
+  const pullId = demand.pullId;
+  if (typeof pullId !== "string" && typeof pullId !== "symbol") {
+    throw new Error("ctx.up: PULL demand requires a string or symbol pullId (D269)");
+  }
+  const params = demand.params;
+  return params === void 0 ? { pullId } : { pullId, params };
+}
+function validateDownPayloads(msgs) {
+  for (const m of msgs) {
+    if (m[0] === "DATA" && m[1] === void 0) {
+      throw new Error("down: DATA requires a non-SENTINEL payload (R-data-payload)");
+    }
+    if (m[0] === "ERROR" && isInvalidErrorPayload(m[1])) {
+      throw new Error("down: ERROR requires a non-SENTINEL, non-boolean payload (R-data-payload)");
+    }
+  }
+}
+var Node = class {
+  _core;
+  _id;
+  _slot;
+  _dep;
+  _value;
+  _wave;
+  _control;
+  _lifecycle;
+  _privateState;
+  _hooks;
+  _syncCtxState;
+  _version;
+  _restoredActivationPending = false;
+  _released = false;
+  get _syncCtx() {
+    return this._syncCtxState.value;
+  }
+  set _syncCtx(ctx) {
+    this._syncCtxState.value = ctx;
+  }
+  constructor(deps, handleOrFn, opts = {}) {
+    const core = constructingCore;
+    constructingCore = void 0;
+    const dispatcher = opts.dispatcher ?? defaultDispatcher;
+    const environment = constructingEnvironment ?? EnvironmentDrivers.empty();
+    constructingEnvironment = void 0;
+    const pool = opts.pool ?? "sync";
+    const pausable = opts.pausable ?? true;
+    const pullLock = opts.pullId;
+    const pull = opts.pullId !== void 0;
+    if (pull && pausable === false)
+      throw new Error(
+        "node: pullId is incompatible with pausable:false \u2014 a pull node uses the pausable delivery-content axis (R-pull / R-pause-modes / D55,D269)"
+      );
+    let handle;
+    if (handleOrFn === null) handle = null;
+    else if (typeof handleOrFn === "function") handle = dispatcher.register(handleOrFn, pool);
+    else handle = handleOrFn;
+    const n = deps.length;
+    const dep = makeDepBookkeeping(n);
+    const versioning = resolveNodeVersioningPolicy(opts.versioning);
+    const value = {
+      cache: SENTINEL,
+      hasData: false,
+      status: "sentinel",
+      terminal: void 0,
+      hasTorndown: false,
+      replayRing: []
+    };
+    if (opts.initial !== void 0) {
+      value.cache = opts.initial;
+      value.hasData = true;
+      value.status = "settled";
+    }
+    const pauseLockset = /* @__PURE__ */ new Set();
+    this._core = core ?? new NodeCore();
+    const created = this._core.createSlot(
+      {
+        deps,
+        handle,
+        pool,
+        dispatcher,
+        environment,
+        partial: opts.partial ?? false,
+        terminalAsRealInput: opts.terminalAsRealInput ?? false,
+        completeWhenDepsComplete: opts.completeWhenDepsComplete ?? true,
+        errorWhenDepsError: opts.errorWhenDepsError ?? true,
+        resubscribable: opts.resubscribable ?? false,
+        resetOnTeardown: opts.resetOnTeardown ?? false,
+        pausable,
+        pull,
+        pullLock,
+        replayN: opts.replayBuffer ?? 0,
+        dynamic: opts.dynamic ?? false,
+        name: opts.name,
+        factory: opts.factory
+      },
+      {
+        dep,
+        lifecycle: { subscribers: /* @__PURE__ */ new Set(), activated: false },
+        value,
+        wave: {
+          pending: 0,
+          hasCalledFnOnce: false,
+          emittedDirtyThisWave: false,
+          emittedSettleThisWave: false,
+          insideRunWave: false,
+          inDepMutation: false,
+          rewireRunPending: false,
+          batchDirtyOwed: false
+        },
+        control: {
+          pauseLockset,
+          pausedDepWaveOccurred: false,
+          pauseBuffer: [],
+          demandOwed: void 0,
+          activePull: void 0,
+          pullDirtyOwed: false,
+          inDeliverDemand: false
+        },
+        privateState: { value: SENTINEL, persist: false },
+        hooks: { onDeactivation: [], onInvalidate: [] },
+        syncCtx: { value: null },
+        version: {
+          policy: versioning,
+          value: createNodeVersion(
+            versioning,
+            opts.initial !== void 0 ? opts.initial : void 0
+          )
+        }
+      }
+    );
+    this._id = created.id;
+    this._slot = this._core.get(this._id);
+    this._dep = this._core.getDep(this._id);
+    this._value = this._core.getValue(this._id);
+    this._wave = this._core.getWave(this._id);
+    this._control = this._core.getControl(this._id);
+    this._lifecycle = this._core.getLifecycle(this._id);
+    this._privateState = this._core.getPrivateState(this._id);
+    this._hooks = this._core.getHooks(this._id);
+    this._syncCtxState = this._core.getSyncCtx(this._id);
+    this._version = this._core.getVersion(this._id);
+    checkpointReaders.set(this, () => ({
+      cache: this._value.cache,
+      hasData: this._value.hasData,
+      terminal: this._value.terminal,
+      activated: this._lifecycle.activated,
+      hasCalledFnOnce: this._wave.hasCalledFnOnce,
+      ctxState: {
+        value: this._privateState.value,
+        persist: this._privateState.persist
+      },
+      version: cloneNodeVersion(this._version.value),
+      handle: this._slot.handle
+    }));
+    restoreWriters.set(this, (state) => {
+      this._assertNotReleased("restoreGraph");
+      this._value.cache = state.cache;
+      this._value.hasData = state.hasData;
+      this._value.status = state.status;
+      this._value.terminal = state.terminal;
+      this._value.hasTorndown = false;
+      this._value.replayRing = [];
+      this._wave.hasCalledFnOnce = state.hasCalledFnOnce;
+      this._wave.emittedDirtyThisWave = false;
+      this._wave.emittedSettleThisWave = false;
+      this._wave.pending = 0;
+      this._wave.insideRunWave = false;
+      this._wave.inDepMutation = false;
+      this._wave.rewireRunPending = false;
+      this._wave.batchDirtyOwed = false;
+      this._control.pauseBuffer = [];
+      this._control.pausedDepWaveOccurred = false;
+      this._control.demandOwed = void 0;
+      this._control.activePull = void 0;
+      this._control.pullDirtyOwed = false;
+      this._control.inDeliverDemand = false;
+      this._control.pauseLockset.clear();
+      this._privateState.value = state.ctxState.value;
+      this._privateState.persist = state.ctxState.persist;
+      if (state.version === false) {
+        this._version.policy = { enabled: false };
+        this._version.value = void 0;
+      } else if (state.version.level === 0) {
+        this._version.policy = { enabled: true, level: 0 };
+        this._version.value = cloneNodeVersion(state.version);
+      } else {
+        if (!this._version.policy.enabled || this._version.policy.level !== 1) {
+          throw new Error(
+            `restoreGraph: checkpoint node version level ${state.version.level} requires matching node versioning policy`
+          );
+        }
+        if (!state.hasData && state.version.counter > 0) {
+          throw new Error(
+            "restoreGraph: checkpoint node version cid cannot be verified without current DATA under V1 versioning (D109)"
+          );
+        }
+        const expectedCid = restoredV1Cid(this._version.policy, state.hasData, state.cache);
+        if (expectedCid !== state.version.cid) {
+          throw new Error(
+            "restoreGraph: checkpoint node version cid does not match the selected node versioning hash policy (D109)"
+          );
+        }
+        this._version.value = cloneNodeVersion(state.version);
+      }
+      this._syncCtx = null;
+      this._resetDepState();
+      this._lifecycle.activated = false;
+      this._lifecycle.subscribers.clear();
+      this._restoredActivationPending = true;
+    });
+    runtimeReleasers.set(this, () => this._releaseRuntime());
+    runtimeQuiescenceReaders.set(this, () => this._isRuntimeQuiescentForRelease());
+    subscriberCountReaders.set(this, () => this._subscriberCount());
+    activationReaders.set(this, () => this._lifecycle.activated);
+  }
+  /** R-pull (D55/D272): true while a pull node is not serving a PULL demand pulse. */
+  _isPullQuiet() {
+    return this._slot.pull && this._control.activePull === void 0;
+  }
+  /**
+   * R-pull (D269/D272): this pull node's pullId (pure data, like {@link cache}/{@link handle} —
+   * never triggers computation). A consumer demands one delivery by cone-routing PULL of it (no
+   * node reference): `ctx.up([["PULL", { pullId }]])` (immediate; loops back → D37 for a self-read
+   * dep) or `ctx.upNext([["PULL", { pullId }]])` (boundary-deferred self-demand). Undefined for a
+   * non-pull node. The author writes the pullId verbatim; routing matches by identity.
+   */
+  get pullId() {
+    return this._slot.pullLock;
+  }
+  get cache() {
+    return this._value.cache;
+  }
+  get status() {
+    return this._value.status;
+  }
+  get version() {
+    return cloneNodeVersion(this._version.value);
+  }
+  get name() {
+    return this._slot.name;
+  }
+  /** R-describe/D51: real factory name for a standalone graph-less node (a runtime *Map inner). */
+  get factory() {
+    return this._slot.factory;
+  }
+  /**
+   * The node's CURRENT/LIVE deps (R-describe / R-edges-derived / D51) — readonly view of the
+   * live `_deps`, which a rewire (C-8 / C-11) mutates. The graph's describe() reads this (NOT a
+   * construction-time snapshot) so every edge corresponds to a real current subscription (D3).
+   * Inspection-only, like cache/status; never triggers computation.
+   */
+  get deps() {
+    return this._slot.deps;
+  }
+  /**
+   * The fn handle (pure data `(poolId, handleId)`, D7) or null for state/passthrough
+   * nodes. Inspection-only (L1.6 handle is referenceable/inspectable) — lets the graph
+   * layer key a dispatcher-backed profile recorder WITHOUT putting counters on the node
+   * (R-node-thin / D39).
+   */
+  get handle() {
+    return this._slot.handle;
+  }
+  /** R-push-subscribe: a new sink receives START, then cached DATA (or DIRTY if dirty). */
+  subscribe(sink) {
+    this._assertNotReleased("subscribe");
+    enterWave();
+    try {
+      if (this._value.terminal !== void 0) {
+        if (this._slot.resubscribable) {
+          this._restoredActivationPending = false;
+          this._resetLifecycle();
+        } else
+          throw new Error(
+            "subscribe: node is non-resubscribable and has terminated; the stream is permanently over (R-terminal / R2.2.7.b)"
+          );
+      }
+      this._lifecycle.subscribers.add(sink);
+      sink(["START"]);
+      if (this._slot.replayN > 0 && this._value.replayRing.length > 0) {
+        for (const v of this._value.replayRing) sink(["DATA", v]);
+      } else if (this._value.hasData && !this._slot.pull) {
+        sink(["DATA", this._value.cache]);
+      } else if (this._value.status === "dirty" && !this._slot.pull) {
+        sink(["DIRTY"]);
+      }
+      if (!this._lifecycle.activated) this._activate();
+      return () => {
+        if (!this._lifecycle.subscribers.delete(sink)) return;
+        if (this._lifecycle.subscribers.size === 0) this._deactivate();
+      };
+    } finally {
+      exitWave();
+    }
+  }
+  /** External emission toward sinks (state-node push, or async late-emit). One call = one wave. */
+  down(msgs) {
+    this._assertNotReleased("down");
+    enterWave();
+    try {
+      this._down(msgs);
+    } finally {
+      exitWave();
+    }
+  }
+  /**
+   * Emit upstream toward deps — control tiers only (R-ctx-up). `towardDep` (a dep index) routes up
+   * ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+   */
+  up(msgs, towardDep) {
+    this._assertNotReleased("up");
+    enterWave();
+    try {
+      this._up(msgs, towardDep);
+    } finally {
+      exitWave();
+    }
+  }
+  // ── deferred self-rewire (R-rewire-deferred / D47): ctx.rewireNext drain support ──
+  /**
+   * Enqueue a deferred self-rewire op (issued from this node's fn via `ctx.rewireNext`).
+   * Applied at the committed wave boundary (boundary.ts drain), never in place — the in-fn
+   * immediate path (`subscribeDep`/`replaceDeps`/`unsubscribeDep`) still throws mid-run (D37/R-reentrancy).
+   */
+  _requestRewireNext(op) {
+    deferRewire(this._core, () => this._applyRewireNext(op), {
+      batchToken: currentBoundaryBatchToken(),
+      isReady: () => !this._hasBoundaryPauseLock()
+    });
+  }
+  /**
+   * Enqueue a deferred up-going control/demand wave (R-up-routing / R-pull / D269): at the committed wave
+   * boundary, route `msgs` up from THIS node (broadcast, or up the single `towardDep` edge). The
+   * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[PULL,
+   * { pullId }]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
+   * the pull node's delivery loops back as a FRESH wave rather than re-entering the consumer (D37 /
+   * R-reentrancy). Rides the same R-rewire-deferred (D47) drain as ctx.rewireNext.
+   */
+  _requestUpNext(msgs, towardDep) {
+    deferRewire(
+      this._core,
+      () => {
+        if (!this._released) this._up(msgs, towardDep);
+      },
+      {
+        batchToken: currentBoundaryBatchToken(),
+        isReady: () => !this._hasBoundaryPauseLock()
+      }
+    );
+  }
+  /** Apply one queued self-rewire at the boundary (drain thunk). */
+  _applyRewireNext(op) {
+    if (this._released) return;
+    try {
+      if (op.kind === "add") {
+        const next = this._slot.deps.includes(op.dep) ? [...this._slot.deps] : [...this._slot.deps, op.dep];
+        this._rewire(next, op.fn, { allowTerminalOwner: true });
+      } else if (op.kind === "remove") {
+        this._rewire(
+          this._slot.deps.filter((d) => d !== op.dep),
+          op.fn,
+          { allowTerminalOwner: true }
+        );
+      } else {
+        this._rewire(this._dedupDeps(op.deps), op.fn, { allowTerminalOwner: true });
+      }
+    } catch (e) {
+      this._down([["ERROR", errorPayload(e, "rewireNext op failed")]]);
+    }
+  }
+  // ── rewire (R-rewire / D42): intra-graph runtime topology mutation ──
+  /**
+   * Replace this node's deps atomically (surgical, Option-C). Requires an explicit
+   * `fn` (SD-1 fn-deps pairing — user fns read dep input positionally). Kept deps
+   * keep their subscription + per-dep state; only removed deps unsubscribe and only
+   * added deps fresh-subscribe (push-on-subscribe for an added cached dep). The
+   * first-run gate and cache are PRESERVED (R-rewire Q2/Q7). Intra-graph only (D22).
+   */
+  replaceDeps(newDeps, fn) {
+    this._assertNotReleased("replaceDeps");
+    this._rewire(this._dedupDeps(newDeps), fn);
+  }
+  /** Subscribe to one dep (special case of replaceDeps); returns its index. fn required (SD-1). */
+  subscribeDep(depNode, fn) {
+    this._assertNotReleased("subscribeDep");
+    const next = this._slot.deps.includes(depNode) ? [...this._slot.deps] : [...this._slot.deps, depNode];
+    const deferred = this._rewire(next, fn);
+    return deferred ? next.indexOf(depNode) : this._slot.deps.indexOf(depNode);
+  }
+  /** Unsubscribe from one dep (special case of replaceDeps); idempotent if absent (fn swap still applies). */
+  unsubscribeDep(depNode, fn) {
+    this._assertNotReleased("unsubscribeDep");
+    this._rewire(
+      this._slot.deps.filter((d) => d !== depNode),
+      fn
+    );
+  }
+  _dedupDeps(deps) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const d of deps)
+      if (!seen.has(d)) {
+        seen.add(d);
+        out.push(d);
+      }
+    return out;
+  }
+  /** Is `target` reachable upstream from `from` (following deps)? Cycle-prevention DFS. */
+  _reachableUpstream(from, target) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [from];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n === void 0) continue;
+      if (n === target) return true;
+      if (seen.has(n)) continue;
+      seen.add(n);
+      for (const d of n._slot.deps) stack.push(d);
+    }
+    return false;
+  }
+  _assertRewireDepOwner(dep) {
+    const selfOwner = getNodeOwner(this);
+    const depOwner = getNodeOwner(dep);
+    if (selfOwner !== void 0 && depOwner !== void 0 && selfOwner !== depOwner) {
+      throw new Error(
+        "rewire: dep belongs to a different graph; cross-graph deps require a wire bridge (D22 / R-graph-domain)"
+      );
+    }
+  }
+  _rewire(newDeps, fn, opts = {}) {
+    if (this._value.terminal !== void 0 && !opts.allowTerminalOwner)
+      throw new Error(
+        "rewire: node is terminal (completed/errored) \u2014 cannot rewire (R-rewire / D42)"
+      );
+    if (this._wave.insideRunWave)
+      throw new Error(
+        "rewire: mid-fn topology mutation \u2014 a fn mutating its own deps mid-wave is the feedback cycle (R-rewire / D37)"
+      );
+    if (this._wave.inDepMutation)
+      throw new Error(
+        "rewire: reentrant dep mutation \u2014 another replaceDeps/subscribeDep/unsubscribeDep is in flight (R-rewire)"
+      );
+    if (newDeps.includes(this))
+      throw new Error("rewire: self-dependency rejected (R-rewire / D42)");
+    const oldDeps = this._slot.deps;
+    const added = newDeps.filter((d) => !oldDeps.includes(d));
+    for (const d of added) {
+      if (this._reachableUpstream(d, this))
+        throw new Error(
+          "rewire: would create a cycle \u2014 dep already transitively depends on this node (R-rewire / D42)"
+        );
+      if (d._value.terminal !== void 0 && !d._slot.resubscribable)
+        throw new Error(
+          "rewire: cannot add a non-resubscribable terminal dep \u2014 would wedge (R-rewire / D42)"
+        );
+      this._assertRewireDepOwner(d);
+    }
+    if (deferAfterBatchForTarget(this, () => {
+      this._rewire(newDeps, fn, { ...opts, allowTerminalOwner: true });
+    })) {
+      return true;
+    }
+    if (!this._lifecycle.activated) this._restoredActivationPending = false;
+    this._wave.inDepMutation = true;
+    this._wave.rewireRunPending = false;
+    let zeroDepUnDirty = false;
+    try {
+      const oldHandle = this._slot.handle;
+      this._slot.handle = this._slot.dispatcher.register(fn, this._slot.pool);
+      if (oldHandle !== null) this._slot.dispatcher.unregister(oldHandle);
+      const removed = oldDeps.filter((d) => !newDeps.includes(d));
+      let removedDirtyContributor = false;
+      for (const d of removed) {
+        const oldIdx = oldDeps.indexOf(d);
+        if (this._dep.dirty[oldIdx]) {
+          removedDirtyContributor = true;
+          this._wave.pending--;
+        }
+        if (this._lifecycle.activated) {
+          const box = this._dep.idxBoxes[oldIdx];
+          if (box) box.v = -1;
+          const unsub = this._dep.unsubs[oldIdx];
+          if (unsub) unsub();
+        }
+      }
+      const n = newDeps.length;
+      const newBatch = new Array(n).fill(null);
+      const newPrev = new Array(n).fill(SENTINEL);
+      const newHasData = new Array(n).fill(false);
+      const newDirty = new Array(n).fill(false);
+      const newTier = new Array(n).fill(0);
+      const newTerminal = new Array(n).fill(void 0);
+      const newTerminalInput = new Array(n).fill(void 0);
+      const newUnsubs = new Array(n);
+      const newBoxes = new Array(n);
+      for (let j = 0; j < n; j++) {
+        const oldIdx = oldDeps.indexOf(newDeps[j]);
+        if (oldIdx !== -1) {
+          newBatch[j] = this._dep.batch[oldIdx];
+          newPrev[j] = this._dep.prev[oldIdx];
+          newHasData[j] = this._dep.hasData[oldIdx];
+          newDirty[j] = this._dep.dirty[oldIdx];
+          newTier[j] = this._dep.tier[oldIdx];
+          newTerminal[j] = this._dep.terminal[oldIdx];
+          newUnsubs[j] = this._dep.unsubs[oldIdx];
+          const box = this._dep.idxBoxes[oldIdx];
+          if (box) box.v = j;
+          newBoxes[j] = box;
+        }
+      }
+      this._slot.deps = newDeps;
+      this._dep.batch = newBatch;
+      this._dep.prev = newPrev;
+      this._dep.hasData = newHasData;
+      this._dep.dirty = newDirty;
+      this._dep.tier = newTier;
+      this._dep.terminal = newTerminal;
+      this._dep.terminalInput = newTerminalInput;
+      this._dep.unsubs = newUnsubs;
+      this._dep.idxBoxes = newBoxes;
+      this._dep.waveData = newDeps.map(() => []);
+      this._dep.waveTokens = new Array(newDeps.length).fill(void 0);
+      this._syncCtx = null;
+      if (this._lifecycle.activated) {
+        for (const d of added) this._subscribeDepAt(d);
+      }
+      notifyTopologyDepsChanged(this, oldDeps, newDeps);
+      if (removedDirtyContributor && this._wave.pending === 0 && this._value.status === "dirty") {
+        if (newDeps.length > 0) this._wave.rewireRunPending = true;
+        else zeroDepUnDirty = true;
+      }
+    } finally {
+      this._wave.inDepMutation = false;
+    }
+    if (this._wave.rewireRunPending) {
+      this._wave.rewireRunPending = false;
+      this._settleRewire();
+    } else if (zeroDepUnDirty) {
+      if (this._wave.emittedDirtyThisWave) this._down([["RESOLVED"]]);
+      else this._value.status = this._value.hasData ? "settled" : "sentinel";
+    }
+    return false;
+  }
+  // ── activation / deactivation (lazy; R-rom-ram) ──
+  _activate() {
+    this._lifecycle.activated = true;
+    const seedRestoredDeps = this._restoredActivationPending;
+    this._restoredActivationPending = false;
+    this._dep.unsubs = new Array(this._slot.deps.length);
+    this._dep.idxBoxes = new Array(this._slot.deps.length);
+    for (const dep of this._slot.deps)
+      this._subscribeDepAt(dep, { seedRestored: seedRestoredDeps });
+    if (this._slot.deps.length === 0 && this._slot.handle !== null && !this._wave.hasCalledFnOnce) {
+      this._runWave();
+    }
+  }
+  /**
+   * Subscribe to a dep. The dispatch callback reads the dep's CURRENT index from a
+   * mutable box (O(1)); a surgical rewire that reorders kept deps just updates the box
+   * (R-rewire Option-C / D42) — no re-subscribe, no per-message indexOf scan. A removed
+   * dep's box is set to -1 so any stale in-flight callback drops (drain).
+   */
+  _subscribeDepAt(depNode, opts = {}) {
+    const idx0 = this._slot.deps.indexOf(depNode);
+    const box = { v: idx0 };
+    let ignoreInitialPush = opts.seedRestored === true;
+    if (ignoreInitialPush && idx0 !== -1) {
+      this._seedRestoredDepAt(idx0, depNode);
+      if (depNode._value.terminal !== void 0 && !depNode._slot.resubscribable) {
+        this._dep.unsubs[idx0] = () => {
+        };
+        this._dep.idxBoxes[idx0] = box;
+        return;
+      }
+    }
+    const unsub = depNode.subscribe((msg, delivery) => {
+      if (ignoreInitialPush && delivery === void 0) return;
+      if (ignoreInitialPush) ignoreInitialPush = false;
+      if (box.v === -1) return;
+      this._receiveFromDep(box.v, msg, delivery);
+    });
+    if (ignoreInitialPush && idx0 !== -1 && box.v !== -1) this._seedRestoredDepAt(idx0, depNode);
+    ignoreInitialPush = false;
+    if (idx0 !== -1) {
+      this._dep.unsubs[idx0] = unsub;
+      this._dep.idxBoxes[idx0] = box;
+    }
+  }
+  _seedRestoredDepAt(idx, depNode) {
+    const seedData = depNode._value.hasData && !depNode._slot.pull;
+    this._dep.batch[idx] = null;
+    this._dep.waveData[idx] = [];
+    this._dep.waveTokens[idx] = void 0;
+    this._dep.prev[idx] = seedData ? depNode._value.cache : SENTINEL;
+    this._dep.hasData[idx] = seedData;
+    this._dep.dirty[idx] = false;
+    this._dep.tier[idx] = seedData ? 3 : 0;
+    this._dep.terminal[idx] = depNode._value.terminal;
+    this._dep.terminalInput[idx] = void 0;
+  }
+  _deactivate() {
+    this._lifecycle.activated = false;
+    for (const u of this._dep.unsubs) if (u) u();
+    this._dep.unsubs = [];
+    this._dep.idxBoxes = [];
+    for (const fn of this._hooks.onDeactivation) fn();
+    this._hooks.onDeactivation = [];
+    this._hooks.onInvalidate = [];
+    const isCompute = this._slot.handle !== null || this._slot.deps.length > 0;
+    if (isCompute) {
+      this._value.cache = SENTINEL;
+      this._value.hasData = false;
+      this._value.status = "sentinel";
+    }
+    this._resetDepState();
+    this._wave.hasCalledFnOnce = false;
+    this._control.pauseLockset.clear();
+    this._control.pauseBuffer = [];
+    this._control.pausedDepWaveOccurred = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
+    this._value.replayRing = [];
+    if (!this._privateState.persist) this._privateState.value = SENTINEL;
+  }
+  _assertNotReleased(op) {
+    if (this._released)
+      throw new Error(`${op}: node has been released from its graph lifecycle (D122)`);
+  }
+  _subscriberCount() {
+    return this._lifecycle.subscribers.size;
+  }
+  _isRuntimeQuiescentForRelease() {
+    return !this._released && this._value.status !== "dirty" && this._value.status !== "pending" && this._wave.pending === 0 && !this._wave.insideRunWave && !this._wave.inDepMutation && !this._wave.rewireRunPending && !this._wave.batchDirtyOwed && this._dep.dirty.every((dirty) => !dirty) && this._control.pauseBuffer.length === 0 && !this._control.pausedDepWaveOccurred && this._control.demandOwed === void 0 && this._control.activePull === void 0 && !this._control.inDeliverDemand && this._control.pauseLockset.size === 0;
+  }
+  _releaseRuntime() {
+    if (this._released) return;
+    this._released = true;
+    releasedNodes.add(this);
+    let releaseError;
+    const recordReleaseError = (error) => {
+      if (releaseError === void 0) releaseError = error;
+    };
+    this._lifecycle.activated = false;
+    for (const u of this._dep.unsubs) {
+      try {
+        u();
+      } catch (error) {
+        recordReleaseError(error);
+      }
+    }
+    for (const fn of this._hooks.onDeactivation) {
+      try {
+        fn();
+      } catch (error) {
+        recordReleaseError(error);
+      }
+    }
+    this._dep.unsubs = [];
+    this._dep.idxBoxes = [];
+    this._lifecycle.subscribers.clear();
+    if (this._slot.handle !== null) {
+      this._slot.dispatcher.unregister(this._slot.handle);
+      this._slot.handle = null;
+    }
+    this._slot.deps = [];
+    this._dep.batch = [];
+    this._dep.waveData = [];
+    this._dep.waveTokens = [];
+    this._dep.prev = [];
+    this._dep.hasData = [];
+    this._dep.dirty = [];
+    this._dep.tier = [];
+    this._dep.terminal = [];
+    this._dep.terminalInput = [];
+    this._value.cache = SENTINEL;
+    this._value.hasData = false;
+    this._value.status = "sentinel";
+    this._value.terminal = void 0;
+    this._value.replayRing = [];
+    this._privateState.value = SENTINEL;
+    this._privateState.persist = false;
+    this._syncCtx = null;
+    this._resetDepState();
+    this._hooks.onDeactivation = [];
+    this._hooks.onInvalidate = [];
+    this._control.pauseLockset.clear();
+    this._control.pauseBuffer = [];
+    this._control.pausedDepWaveOccurred = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
+    this._restoredActivationPending = false;
+    checkpointReaders.delete(this);
+    restoreWriters.delete(this);
+    runtimeReleasers.delete(this);
+    runtimeQuiescenceReaders.delete(this);
+    subscriberCountReaders.delete(this);
+    activationReaders.delete(this);
+    ownerTokens.delete(this);
+    topologyDepsChangedObservers.delete(this);
+    this._core.releaseSlot(this._id);
+    if (releaseError !== void 0) throw releaseError;
+  }
+  _resetDepState() {
+    const n = this._slot.deps.length;
+    for (let i = 0; i < n; i++) {
+      this._dep.batch[i] = null;
+      this._dep.waveData[i] = [];
+      this._dep.waveTokens[i] = void 0;
+      this._dep.prev[i] = SENTINEL;
+      this._dep.hasData[i] = false;
+      this._dep.dirty[i] = false;
+      this._dep.tier[i] = 0;
+      this._dep.terminal[i] = void 0;
+      this._dep.terminalInput[i] = void 0;
+    }
+    this._wave.pending = 0;
+    this._wave.emittedDirtyThisWave = false;
+  }
+  // ── upstream wave receive (two-phase + diamond) ──
+  _recordDepProjection(idx, delivery) {
+    const token = delivery?.wave ?? {};
+    if (this._dep.waveTokens[idx] !== token) {
+      this._dep.waveData[idx].push([]);
+      this._dep.waveTokens[idx] = token;
+    }
+    return this._dep.waveData[idx][this._dep.waveData[idx].length - 1];
+  }
+  _depProjectionHasData(idx) {
+    const projection = this._dep.waveData[idx][this._dep.waveData[idx].length - 1];
+    return projection?.some((v) => v !== SENTINEL) ?? false;
+  }
+  _receiveFromDep(idx, msg, delivery) {
+    if (this._released) return;
+    const t = msg[0];
+    if (t === "START") return;
+    const isLastInDeliveredWave = delivery?.last ?? true;
+    if (this._value.terminal !== void 0) {
+      if (t === "TEARDOWN") this._down([["TEARDOWN"]]);
+      return;
+    }
+    if (t === "INVALIDATE") {
+      const projection = this._recordDepProjection(idx, delivery);
+      projection.push(SENTINEL);
+      if (projection.some((v) => v !== SENTINEL) && isLastInDeliveredWave) this._maybeRun();
+      this._dep.prev[idx] = SENTINEL;
+      this._dep.hasData[idx] = false;
+      this._dep.batch[idx] = null;
+      if (this._dep.dirty[idx]) {
+        this._dep.dirty[idx] = false;
+        this._wave.pending--;
+      }
+      if (this._control.pausedDepWaveOccurred && this._dep.batch.every((b) => b === null)) {
+        this._control.pausedDepWaveOccurred = false;
+      }
+      const hadData = this._value.hasData;
+      this._invalidate();
+      if (this._wave.pending === 0 && this._wave.emittedDirtyThisWave) {
+        if (!hadData) this._down([["RESOLVED"]]);
+        else this._wave.emittedDirtyThisWave = false;
+      }
+      this._fireOwedDemandIfReady();
+      return;
+    }
+    if (isTerminal(t)) {
+      const isError = t === "ERROR";
+      const errPayload = isError ? msg[1] : void 0;
+      this._dep.terminal[idx] = isError ? errPayload : true;
+      this._dep.terminalInput[idx] = isError ? errPayload : true;
+      this._releaseDepDirty(idx);
+      const ranValueBeforeTerminal = this._depProjectionHasData(idx) && isLastInDeliveredWave;
+      if (ranValueBeforeTerminal) this._maybeRun();
+      if (isError && this._slot.errorWhenDepsError) {
+        this._down([["ERROR", errPayload]]);
+      } else if (this._slot.terminalAsRealInput) {
+        if (ranValueBeforeTerminal) {
+          this._fireOwedDemandIfReady();
+          return;
+        }
+        this._maybeRun();
+      } else if (this._slot.completeWhenDepsComplete && this._allDepsTerminal()) {
+        this._down([["COMPLETE"]]);
+      } else {
+        this._settleAfterAbsorbedTerminal();
+      }
+      this._fireOwedDemandIfReady();
+      return;
+    }
+    if (t === "TEARDOWN") {
+      this._down([["TEARDOWN"]]);
+      return;
+    }
+    if (t === "DIRTY") {
+      if (!this._dep.dirty[idx]) {
+        this._dep.dirty[idx] = true;
+        this._wave.pending++;
+        this._dep.tier[idx] = 2;
+        this._markDirty();
+      }
+      return;
+    }
+    if (t === "DATA") {
+      const v = msg[1];
+      this._recordDepProjection(idx, delivery).push(v);
+      const b = this._dep.batch[idx];
+      if (b === null) this._dep.batch[idx] = [v];
+      else b.push(v);
+      this._dep.prev[idx] = v;
+      this._dep.hasData[idx] = true;
+      this._dep.tier[idx] = 3;
+      if (this._dep.dirty[idx]) {
+        this._dep.dirty[idx] = false;
+        this._wave.pending--;
+      }
+      if (isLastInDeliveredWave) this._maybeRun();
+      this._fireOwedDemandIfReady();
+      return;
+    }
+    if (t === "RESOLVED") {
+      this._recordDepProjection(idx, delivery);
+      this._dep.tier[idx] = 3;
+      if (this._dep.dirty[idx]) {
+        this._dep.dirty[idx] = false;
+        this._wave.pending--;
+      }
+      if (isLastInDeliveredWave) this._maybeRun();
+      this._fireOwedDemandIfReady();
+      return;
+    }
+  }
+  /**
+   * R-terminal-settles-dirty (B35): release a dep's outstanding in-wave DIRTY contribution.
+   * A settle-class event for that dep (DATA/RESOLVED inline above, INVALIDATE, and now
+   * COMPLETE/ERROR) clears its dirty flag + decrements _pending. No-op if the dep already
+   * settled this wave (DATA/RESOLVED ran first) — so the normal DATA-then-COMPLETE flow is
+   * unaffected. This makes the exactly-one-settle invariant a single, shared step.
+   */
+  _releaseDepDirty(idx) {
+    if (this._dep.dirty[idx]) {
+      this._dep.dirty[idx] = false;
+      this._wave.pending--;
+    }
+  }
+  /**
+   * R-terminal-settles-dirty (B35): settle a node whose dirtied dep was released by an ABSORBED
+   * terminal that is NOT a real input (a plain derived/effect — the common default-node case when
+   * one of several deps completes while others stay live). Runs only when the release drained
+   * _pending while the node still owes a downstream settle (it broadcast DIRTY this wave):
+   *   - if some OTHER dep delivered real DATA this wave (a value occurred) → recompute (→ DATA);
+   *   - else the terminal's signalled change did not materialise (no value) → one undirty RESOLVED
+   *     (R-resolved-undirty), keeping the cache (a terminal, unlike INVALIDATE, leaves the value).
+   * A terminalAsRealInput node instead recomputes unconditionally (its fn reads the terminal).
+   */
+  _settleAfterAbsorbedTerminal() {
+    if (this._wave.pending !== 0 || !this._wave.emittedDirtyThisWave) return;
+    const sawData = this._dep.batch.some((b) => b !== null && b.length > 0);
+    if (sawData) this._maybeRun();
+    if (this._wave.emittedDirtyThisWave) this._down([["RESOLVED"]]);
+  }
+  _markDirty() {
+    this._value.status = "dirty";
+    if (this._isPullQuiet()) return;
+    if (!this._wave.emittedDirtyThisWave) {
+      this._wave.emittedDirtyThisWave = true;
+      this._emitToSubs(["DIRTY"]);
+    }
+  }
+  _maybeRun() {
+    if (this._wave.inDepMutation) {
+      this._wave.rewireRunPending = true;
+      return;
+    }
+    if (this._slot.pausable === true && (this._isPaused() || this._isPullQuiet())) {
+      this._control.pausedDepWaveOccurred = true;
+      return;
+    }
+    this._tryRun();
+  }
+  /**
+   * R-rewire atomic settle (after a rewire that warrants a recompute): emit a proper
+   * two-phase DIRTY→DATA wave (R-dirty-before-data — a rewire-triggered settle is a wave),
+   * once, with every added dep already wired. Mirrors _maybeRun/_tryRun's pause + gate +
+   * pending guards, then injects the phase-1 DIRTY the added dep's [START,DATA] handshake
+   * did not carry.
+   */
+  _settleRewire() {
+    if (this._slot.pausable === true && this._isPaused()) {
+      this._control.pausedDepWaveOccurred = true;
+      return;
+    }
+    if (this._wave.pending > 0) return;
+    if (this._slot.handle === null) {
+      this._passthroughEmit();
+      return;
+    }
+    if (!this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled())) return;
+    this._markDirty();
+    this._runWave();
+  }
+  _tryRun() {
+    if (this._wave.pending > 0) return;
+    if (this._slot.handle === null) {
+      this._passthroughEmit();
+      return;
+    }
+    if (!this._wave.hasCalledFnOnce) {
+      if (this._slot.partial || this._allDepsSettled()) this._runWave();
+      return;
+    }
+    this._runWave();
+  }
+  _allDepsSettled() {
+    for (let i = 0; i < this._slot.deps.length; i++) {
+      if (this._dep.hasData[i]) continue;
+      if (this._slot.terminalAsRealInput && this._dep.terminal[i] !== void 0) continue;
+      return false;
+    }
+    return true;
+  }
+  _passthroughEmit() {
+    const b = this._dep.batch[0];
+    if (b !== null && b.length > 0) {
+      this._down([["DATA", b[b.length - 1]]]);
+    } else if (this._wave.emittedDirtyThisWave) {
+      this._down([["RESOLVED"]]);
+    }
+    this._dep.batch[0] = null;
+    this._wave.emittedDirtyThisWave = false;
+  }
+  _runWave() {
+    if (this._wave.insideRunWave)
+      throw new Error(
+        "synchronous feedback cycle: node fn re-entered its own wave (R-reentrancy / D37)"
+      );
+    this._wave.hasCalledFnOnce = true;
+    this._hooks.onInvalidate = [];
+    this._hooks.onDeactivation = [];
+    const ctx = this._buildCtx();
+    const wasDirty = this._wave.emittedDirtyThisWave;
+    this._wave.emittedSettleThisWave = false;
+    this._wave.insideRunWave = true;
+    try {
+      this._slot.dispatcher.invoke(this._slot.handle, ctx);
+    } finally {
+      this._wave.insideRunWave = false;
+    }
+    if (wasDirty && !this._wave.emittedSettleThisWave && this._value.terminal === void 0 && !this._isAsyncPool()) {
+      this._down([["RESOLVED"]]);
+    }
+    for (let i = 0; i < this._dep.batch.length; i++) {
+      this._dep.batch[i] = null;
+      this._dep.waveData[i] = [];
+      this._dep.waveTokens[i] = void 0;
+      this._dep.terminalInput[i] = void 0;
+    }
+    this._wave.emittedDirtyThisWave = false;
+  }
+  // ── ctx construction (L3-Q5: sync = node-stable reused ctx; async = per-invocation) ──
+  _buildCtx() {
+    const kind = this._slot.handle ? this._slot.dispatcher.poolKind(this._slot.handle.poolId) : "sync";
+    if (kind === "sync") {
+      if (this._syncCtx === null) this._syncCtx = this._makeCtx();
+      this._refreshCtx(this._syncCtx);
+      return this._syncCtx;
+    }
+    return this._makeCtx({
+      waveData: this._dep.waveData.map((waves) => waves.map((w) => [...w])),
+      terminal: this._dep.terminalInput.map(terminalView),
+      latest: [...this._dep.prev]
+    });
+  }
+  _makeCtx(snapshot) {
+    const ctx = {
+      // Wave-owner boundary (D47): a SYNC fn's emit nests under the public entry that drove
+      // it (cheap inc/dec, no early drain); an ASYNC-pool fn re-enters here from its stashed
+      // ctx at depth 0, so this is the boundary that drains any rewireNext it issued.
+      up: (msgs, towardDep) => {
+        if (this._released) return;
+        enterWave();
+        try {
+          this._up(msgs, towardDep);
+        } finally {
+          exitWave();
+        }
+      },
+      down: (msgs) => {
+        if (this._released) return;
+        enterWave();
+        try {
+          this._down(msgs);
+        } finally {
+          exitWave();
+        }
+      },
+      waveData: snapshot?.waveData ?? this._dep.waveData,
+      terminal: snapshot?.terminal ?? this._dep.terminalInput.map(terminalView),
+      state: this._makeState(),
+      onDeactivation: (fn) => {
+        if (this._released) return;
+        this._hooks.onDeactivation.push(fn);
+      },
+      onInvalidate: (fn) => {
+        if (this._released) return;
+        this._hooks.onInvalidate.push(fn);
+      },
+      environment: () => this._slot.environment,
+      // R-rewire-deferred (D47): defer a self-dep-set mutation to the committed boundary.
+      rewireNext: {
+        subscribeDep: (dep, fn) => this._requestRewireNext({ kind: "add", dep, fn }),
+        unsubscribeDep: (dep, fn) => this._requestRewireNext({ kind: "remove", dep, fn }),
+        replaceDeps: (deps, fn) => this._requestRewireNext({ kind: "set", deps, fn })
+      },
+      // R-up-routing / R-pull (D269): deferred up — route a control/demand wave (e.g. PULL)
+      // up the declared cone at the committed boundary. The SELF-demand path: an
+      // immediate ctx.up whose delivery loops back re-enters this fn (D37 / R-reentrancy).
+      upNext: (msgs, towardDep) => this._requestUpNext(msgs, towardDep),
+      ...this._control.activePull === void 0 ? {} : { pull: this._control.activePull },
+      [CTX_DEP_CACHE]: { latest: snapshot?.latest ?? this._dep.prev },
+      [CTX_NODE_BINDING]: {
+        dispatcher: this._slot.dispatcher,
+        create: (factory) => withEnvironmentDrivers(this._slot.environment, () => withNodeCore(this._core, factory))
+      }
+    };
+    if (this._slot.dynamic) {
+      ctx.track = (i) => ctx[CTX_DEP_CACHE]?.latest[i];
+    }
+    return ctx;
+  }
+  _refreshCtx(ctx) {
+    ctx.waveData = this._dep.waveData;
+    ctx.terminal = this._dep.terminalInput.map(terminalView);
+    if (this._control.activePull === void 0) {
+      delete ctx.pull;
+    } else {
+      ctx.pull = this._control.activePull;
+    }
+    ctx[CTX_DEP_CACHE] = { latest: this._dep.prev };
+  }
+  _makeState() {
+    return {
+      get: () => this._privateState.value,
+      set: (v) => {
+        this._privateState.value = v;
+      },
+      persist: (on = true) => {
+        this._privateState.persist = on;
+      }
+    };
+  }
+  // ── downstream emission pipeline (the unified waist) ──
+  _down(msgs) {
+    if (this._released) return;
+    validateDownPayloads(msgs);
+    const deliveryWave = {};
+    const assertVersionDataCompatible = (wave) => {
+      for (const m of wave) {
+        if (m[0] === "DATA") assertNodeVersionDataCompatible(this._version.policy, m[1]);
+      }
+    };
+    const snapshotVersionData = (wave) => wave.map(
+      (m) => m[0] === "DATA" ? ["DATA", snapshotNodeVersionData(this._version.policy, m[1])] : m
+    );
+    assertVersionDataCompatible(msgs);
+    if (this._value.terminal !== void 0) {
+      if (!msgs.some((m) => m[0] === "TEARDOWN")) return;
+      this._value.hasTorndown = true;
+      if (this._slot.resetOnTeardown) {
+        this._value.cache = SENTINEL;
+        this._value.hasData = false;
+      }
+      this._emitToSubs(["TEARDOWN"], { wave: deliveryWave, last: true });
+      return;
+    }
+    let sorted = [...msgs].sort((a, b) => messageTier(a[0]) - messageTier(b[0]));
+    const firstInvalidate = sorted.findIndex((m) => m[0] === "INVALIDATE");
+    if (firstInvalidate !== -1) {
+      sorted = sorted.filter((m, i) => m[0] !== "INVALIDATE" || i === firstInvalidate);
+    }
+    const hasTeardown = sorted.some((m) => m[0] === "TEARDOWN");
+    const hasTerminal = sorted.some((m) => m[0] === "COMPLETE" || m[0] === "ERROR");
+    if (hasTeardown && !hasTerminal && this._value.terminal === void 0 && !this._value.hasTorndown) {
+      sorted = [["COMPLETE"], ...sorted];
+    }
+    if (!this._wave.insideRunWave && currentBatch()) {
+      const deferred = snapshotVersionData(sorted.filter((m) => isDeferredTier(m[0])));
+      if (deferred.length > 0) {
+        if (!this._wave.emittedDirtyThisWave) {
+          this._wave.emittedDirtyThisWave = true;
+          this._value.status = "dirty";
+          this._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+        }
+        this._wave.batchDirtyOwed = true;
+        deferToBatch(this, deferred);
+        return;
+      }
+    }
+    if (this._shouldBufferOnPause()) {
+      const buffered = snapshotVersionData(sorted.filter((m) => isPauseBufferedTier(m[0])));
+      if (buffered.length > 0) {
+        this._wave.emittedSettleThisWave = true;
+        this._control.pauseBuffer.push(buffered);
+      }
+      sorted = sorted.filter((m) => !isPauseBufferedTier(m[0]));
+      if (sorted.length === 0) return;
+    }
+    let dataCount = 0;
+    let hasTier3 = false;
+    let hasResolved = false;
+    for (const m of sorted) {
+      if (m[0] === "DATA") dataCount++;
+      if (m[0] === "RESOLVED") hasResolved = true;
+      if (isValueTier(m[0])) hasTier3 = true;
+    }
+    if (dataCount >= 1 && hasResolved) {
+      throw new Error(
+        "down: a wave cannot mix DATA and RESOLVED (tier-3 exclusivity, R-resolved-undirty)"
+      );
+    }
+    const plannedVersions = new Array(sorted.length);
+    if (dataCount > 0) {
+      let plannedVersion = this._version.value;
+      for (let i = 0; i < sorted.length; i++) {
+        const m = sorted[i];
+        if (m[0] !== "DATA") continue;
+        plannedVersion = advanceNodeVersion(plannedVersion, this._version.policy, m[1]);
+        plannedVersions[i] = plannedVersion;
+      }
+    }
+    if (hasTier3 && (!this._wave.insideRunWave || this._control.pullDirtyOwed) && !this._wave.emittedDirtyThisWave) {
+      this._wave.emittedDirtyThisWave = true;
+      this._value.status = "dirty";
+      this._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+    }
+    for (let i = 0; i < sorted.length; i++) {
+      const m = sorted[i];
+      const delivery = { wave: deliveryWave, last: i === sorted.length - 1 };
+      if (isDeferredTier(m[0])) this._wave.emittedSettleThisWave = true;
+      if (m[0] === "DIRTY") {
+        if (!this._wave.emittedDirtyThisWave) {
+          this._wave.emittedDirtyThisWave = true;
+          this._value.status = "dirty";
+          this._emitToSubs(["DIRTY"], delivery);
+        }
+        continue;
+      }
+      if (m[0] === "DATA") {
+        const v = m[1];
+        this._value.cache = v;
+        this._value.hasData = true;
+        this._value.status = "settled";
+        this._version.value = plannedVersions[i];
+        if (this._slot.replayN > 0) {
+          this._value.replayRing.push(v);
+          if (this._value.replayRing.length > this._slot.replayN) this._value.replayRing.shift();
+        }
+        this._emitToSubs(["DATA", v], delivery);
+        continue;
+      }
+      if (m[0] === "RESOLVED") {
+        this._value.status = this._value.hasData ? "resolved" : "sentinel";
+        this._emitToSubs(["RESOLVED"], delivery);
+        continue;
+      }
+      if (m[0] === "INVALIDATE") {
+        this._invalidate(delivery);
+        continue;
+      }
+      if (m[0] === "COMPLETE") {
+        if (this._value.terminal !== void 0) continue;
+        this._value.terminal = true;
+        this._control.pauseBuffer = [];
+        this._value.status = "completed";
+        this._emitToSubs(["COMPLETE"], delivery);
+        continue;
+      }
+      if (m[0] === "ERROR") {
+        if (this._value.terminal !== void 0) continue;
+        this._value.terminal = m[1];
+        this._control.pauseBuffer = [];
+        this._value.status = "errored";
+        this._emitToSubs(["ERROR", m[1]], delivery);
+        continue;
+      }
+      if (m[0] === "TEARDOWN") {
+        this._value.hasTorndown = true;
+        if (this._slot.resetOnTeardown) {
+          this._value.cache = SENTINEL;
+          this._value.hasData = false;
+        }
+        this._emitToSubs(["TEARDOWN"], delivery);
+      }
+    }
+    if (!this._wave.insideRunWave) this._wave.emittedDirtyThisWave = false;
+  }
+  _up(msgs, towardDep, route) {
+    if (this._released) return;
+    const routeState = route ?? { demandFired: /* @__PURE__ */ new Map() };
+    for (const m of msgs) {
+      if (!isUpAllowed(m[0])) {
+        throw new Error(
+          `ctx.up: ${m[0]} is down-only (tier ${messageTier(m[0])}); up carries control tiers only (R-ctx-up)`
+        );
+      }
+    }
+    for (const m of msgs) {
+      if (m[0] === "PAUSE") {
+        this._pauseAcquire(m[1]);
+      } else if (m[0] === "RESUME") {
+        if (this._control.pauseLockset.has(m[1])) {
+          this._pauseRelease(m[1]);
+        } else {
+          this._forwardUp(m, towardDep, routeState);
+        }
+      } else if (m[0] === "PULL") {
+        const demand = normalizePullDemand(m[1]);
+        if (this._slot.pull && demand.pullId === this._slot.pullLock) {
+          if (!this._markDemandRouted(demand.pullId, routeState)) this._onDemand(demand);
+        } else {
+          this._forwardUp(["PULL", demand], towardDep, routeState);
+        }
+      } else if (this._slot.deps.length === 0) {
+        if (m[0] === "INVALIDATE") this._down([["INVALIDATE"]]);
+      } else {
+        this._forwardUp(m, towardDep, routeState);
+      }
+    }
+  }
+  _markDemandRouted(lockId, route) {
+    let holders = route.demandFired.get(lockId);
+    if (holders === void 0) {
+      holders = /* @__PURE__ */ new Set();
+      route.demandFired.set(lockId, holders);
+    }
+    if (holders.has(this)) return true;
+    holders.add(this);
+    return false;
+  }
+  /**
+   * Forward one up-going control message toward deps (R-up-routing): up the single declared edge
+   * `towardDep` (directed — prunes other branches; only meaningful on the issuer's FIRST hop) or
+   * broadcast up ALL deps. A depless source has no deps → the message DROPS here (the terminus —
+   * e.g. a cone-routed PULL whose pullId no node up this cone holds, R-up-at-source). Recursive
+   * forwarding carries the same per-wave route state and no `towardDep` → broadcast beyond the
+   * first hop.
+   */
+  _forwardUp(m, towardDep, route) {
+    if (this._slot.deps.length === 0) return;
+    if (towardDep !== void 0) {
+      const d = this._slot.deps[towardDep];
+      if (d !== void 0) d._up([m], void 0, route);
+    } else {
+      for (const dep of this._slot.deps) dep._up([m], void 0, route);
+    }
+  }
+  // ── PAUSE/RESUME lockset (R-pause-lockset) + modes (R-pause-modes) ──
+  _isPaused() {
+    return this._control.pauseLockset.size > 0;
+  }
+  _hasBoundaryPauseLock() {
+    if (this._slot.pausable === false) return false;
+    return this._control.pauseLockset.size > 0;
+  }
+  _isAsyncPool() {
+    return this._slot.handle !== null && this._slot.dispatcher.poolKind(this._slot.handle.poolId) === "async";
+  }
+  _pauseAcquire(lockId) {
+    this._control.pauseLockset.add(lockId);
+  }
+  _pauseRelease(lockId) {
+    if (!this._control.pauseLockset.has(lockId)) return;
+    this._control.pauseLockset.delete(lockId);
+    if (this._slot.pull && this._control.demandOwed !== void 0) this._fireOwedDemandIfReady();
+    if (this._hasBoundaryPauseLock()) return;
+    scheduleBoundaryDrain(this._core);
+    if (this._slot.pull) return;
+    this._onResume();
+  }
+  _onResume() {
+    if (this._value.terminal !== void 0) {
+      this._control.pauseBuffer = [];
+      this._control.pausedDepWaveOccurred = false;
+      this._control.demandOwed = void 0;
+      this._control.activePull = void 0;
+      this._control.pullDirtyOwed = false;
+      return;
+    }
+    if (this._control.pauseBuffer.length > 0) {
+      const buf = this._control.pauseBuffer;
+      this._control.pauseBuffer = [];
+      for (const wave of buf) this._down(wave);
+    }
+    if (this._control.pausedDepWaveOccurred) {
+      this._control.pausedDepWaveOccurred = false;
+      this._tryRun();
+    }
+  }
+  /**
+   * R-pull (D269): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
+   * and no OTHER (non-pullId) lock holds it paused. The gate that decides fire-now vs OWE.
+   */
+  _canFireDemand() {
+    if (this._value.terminal !== void 0 || this._wave.pending > 0) return false;
+    return this._control.pauseLockset.size === 0;
+  }
+  /**
+   * R-pull (D269/D272): deliver ONE demand pulse — install activePull so the demand wave may
+   * emit, fire it, then clear activePull so the node is quiet again (1:1).
+   */
+  _deliverPullDemand(demand) {
+    this._control.demandOwed = void 0;
+    this._control.activePull = demand;
+    this._control.inDeliverDemand = true;
+    try {
+      this._firePullDemand();
+    } finally {
+      this._control.activePull = void 0;
+      this._control.inDeliverDemand = false;
+    }
+  }
+  /**
+   * R-pull (D269): a cone-routed PULL of THIS node's pullId arrived (R-up-routing) = a DEMAND.
+   * Fire immediately if able; else OWE it — pin-5 (a dep DIRTY in flight, _pending>0) or F4/F5 (an
+   * external PAUSE lock co-holds the node) — and fire when the node next becomes able. A demand
+   * arriving WHILE a delivery is in flight (synchronous re-entry) is DROPPED (1:1, QA guard).
+   */
+  _onDemand(demand) {
+    if (this._control.inDeliverDemand) return;
+    if (this._canFireDemand()) this._deliverPullDemand(demand);
+    else this._control.demandOwed = demand;
+  }
+  /**
+   * R-pull (D55): service ONE demand. Delivery content = the orthogonal pausable mode:
+   *   - 'resumeAll' → drain the buffered BACKLOG (each `_down` re-synthesizes a leading DIRTY, so
+   *     the per-entry replay is DIRTY-before-DATA — R-pause-modes per-entry arrival order);
+   *   - true → deliver the coalesced LATEST as ONE DIRTY-before-DATA wave (pin 2: the quiet absorb
+   *     suppressed the dep's original DIRTY, so the demand wave restores it before the value).
+   * Neither branch fires when nothing changed since the last demand → the demand is SILENT.
+   * Called by `_deliverPullDemand` only when settle-ready; the caller has released the pullId, so
+   * `_markDirty` relays the leading DIRTY (not absorbed).
+   */
+  _firePullDemand() {
+    let drainedBuffer = false;
+    if (this._control.pauseBuffer.length > 0) {
+      const buf = this._control.pauseBuffer;
+      this._control.pauseBuffer = [];
+      for (const wave of buf) this._down(wave);
+      drainedBuffer = true;
+    }
+    if (drainedBuffer) return;
+    if (this._control.pausedDepWaveOccurred) {
+      const gated = this._slot.handle !== null && !this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled());
+      if (this._wave.pending > 0 || gated) return;
+      this._control.pausedDepWaveOccurred = false;
+      this._wave.emittedDirtyThisWave = false;
+      this._control.pullDirtyOwed = true;
+      try {
+        this._tryRun();
+      } finally {
+        this._control.pullDirtyOwed = false;
+      }
+      return;
+    }
+    if (this._slot.handle !== null) {
+      if (!this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled())) return;
+      this._wave.emittedDirtyThisWave = false;
+      this._control.pullDirtyOwed = true;
+      try {
+        this._runWave();
+      } finally {
+        this._control.pullDirtyOwed = false;
+      }
+    }
+  }
+  /**
+   * R-pull (D269): fire a demand that was OWED (deferred at demand time) once the node becomes
+   * able — called from the dep-settle arms (DATA/RESOLVED/INVALIDATE/terminal drain _pending, pin-5
+   * + B1/F6) and from `_pauseRelease` (an external PAUSE lock releases, F4/F5).
+   */
+  _fireOwedDemandIfReady() {
+    if (this._control.inDeliverDemand) return;
+    if (this._slot.pull && this._control.demandOwed !== void 0 && this._canFireDemand()) {
+      this._deliverPullDemand(this._control.demandOwed);
+    }
+  }
+  /** Should an outgoing settle slice be deferred into the pause buffer? */
+  _shouldBufferOnPause() {
+    if (this._slot.pausable === false) return false;
+    if (!this._isPaused() && !this._isPullQuiet()) return false;
+    if (this._slot.pausable === "resumeAll") return true;
+    if (!this._wave.insideRunWave && this._isAsyncPool() && this._slot.deps.length > 0) return true;
+    return false;
+  }
+  /** R-invalidate-idempotent: clear cache + flush + cascade; no-op if nothing cached. */
+  _invalidate(delivery) {
+    if (!this._value.hasData) return;
+    this._value.cache = SENTINEL;
+    this._value.hasData = false;
+    this._value.status = "sentinel";
+    this._value.replayRing = [];
+    for (const fn of this._hooks.onInvalidate) fn();
+    this._emitToSubs(["INVALIDATE"], delivery);
+  }
+  // B42 (R-deps-terminal): ALL deps TERMINAL = every dep has reached COMPLETE *or* an ABSORBED
+  // ERROR. Block only on a LIVE dep (_depTerminal[i] === undefined); an errored dep (terminal = the
+  // error payload, which R-data-payload guarantees is !== undefined and non-boolean) COUNTS as
+  // terminal-done. Was
+  // `tm !== true`, which wedged a node whose errorWhenDepsError:false dep ERRORed (it never
+  // auto-completed even after every other dep completed). Drives the completeWhenDepsComplete cascade.
+  _allDepsTerminal() {
+    if (this._slot.deps.length === 0) return false;
+    for (const tm of this._dep.terminal) if (tm === void 0) return false;
+    return true;
+  }
+  /** R-terminal: resubscribable reset clears terminal + dep state + re-arms the gate. */
+  _resetLifecycle() {
+    for (const u of this._dep.unsubs) if (u) u();
+    this._dep.unsubs = [];
+    this._dep.idxBoxes = [];
+    this._lifecycle.subscribers.clear();
+    this._lifecycle.activated = false;
+    this._value.terminal = void 0;
+    this._value.hasTorndown = false;
+    this._wave.hasCalledFnOnce = false;
+    this._resetDepState();
+    this._control.pauseLockset.clear();
+    this._control.pauseBuffer = [];
+    this._control.pausedDepWaveOccurred = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
+    this._value.replayRing = [];
+    const isCompute = this._slot.handle !== null || this._slot.deps.length > 0;
+    if (isCompute) {
+      this._value.cache = SENTINEL;
+      this._value.hasData = false;
+      this._value.status = "sentinel";
+    } else {
+      this._value.status = this._value.hasData ? "settled" : "sentinel";
+    }
+    if (!this._privateState.persist) this._privateState.value = SENTINEL;
+  }
+  _emitToSubs(msg, delivery) {
+    if (this._released) return;
+    const subs = [...this._lifecycle.subscribers];
+    for (const sink of subs) sink(msg, delivery);
+  }
+  /** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
+  __commitBatchedWave(wave) {
+    this._wave.batchDirtyOwed = false;
+    this._down(wave);
+  }
+  /** Batch rollback: balance the immediate DIRTY with a RESOLVED so downstream un-dirties. */
+  __rollbackBatched() {
+    if (this._wave.batchDirtyOwed) {
+      this._wave.batchDirtyOwed = false;
+      this._wave.emittedDirtyThisWave = false;
+      this._value.status = this._value.hasData ? "settled" : "sentinel";
+      this._emitToSubs(["RESOLVED"]);
+    }
+  }
+  /** B49: enqueue a committed-boundary task on this node's graph-local core. */
+  __deferBoundary(fn, batchToken) {
+    deferRewire(this._core, fn, {
+      batchToken,
+      isReady: () => !this._hasBoundaryPauseLock()
+    });
+  }
+};
+
+// src/solutions/reactive-layout/index.ts
+var TEXT_SEGMENTS_MEASUREMENT_KIND = "text-segments";
+var BLOCKS_MEASUREMENT_KIND = "blocks";
+var READINESS_MEASUREMENT_KIND = "readiness";
+var IMAGE_SIZE_MEASUREMENT_KIND = "image-size";
+var SVG_BOUNDS_MEASUREMENT_KIND = "svg-bounds";
+var kinsokuStart = /* @__PURE__ */ new Set([
+  "\u3001",
+  "\u3002",
+  "\u30FB",
+  "\uFF09",
+  "\u3015",
+  "\u3009",
+  "\u300B",
+  "\u300D",
+  "\u300F",
+  "\u3011"
+]);
+var leftStickyPunctuation = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "\u201D",
+  "\u2019",
+  "\xBB",
+  "\u203A",
+  "\u2026"
+]);
+function isCJK(text) {
+  for (const ch of text) {
+    const c = ch.codePointAt(0);
+    if (c !== void 0 && c >= 19968 && c <= 40959 || c !== void 0 && c >= 13312 && c <= 19903 || c !== void 0 && c >= 12288 && c <= 12351 || c !== void 0 && c >= 12352 && c <= 12447 || c !== void 0 && c >= 44032 && c <= 55215 || c !== void 0 && c >= 65280 && c <= 65519) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/[\t\f ]+/g, " ").replace(/^ | $/g, "");
+}
+function segmentText(text, segmentAdapter) {
+  const pieces = [];
+  for (const s of segmentAdapter.segmentWords(text)) {
+    const wordSegment = s.segment;
+    const rawWordLike = s.isWordLike ?? false;
+    const pieceTexts = [];
+    const pieceWordLikes = [];
+    const pieceKinds = [];
+    let currentText = "";
+    let currentKind = null;
+    for (const ch of wordSegment) {
+      let kind;
+      if (ch === " ") {
+        kind = "space";
+      } else if (ch === "\u200B") {
+        kind = "zero-width-break";
+      } else if (ch === "\xAD") {
+        kind = "soft-hyphen";
+      } else if (ch === "\n") {
+        kind = "hard-break";
+      } else {
+        kind = "text";
+      }
+      if (currentKind !== null && kind === currentKind) {
+        currentText += ch;
+      } else {
+        if (currentKind !== null) {
+          pieceTexts.push(currentText);
+          pieceWordLikes.push(currentKind === "text" && rawWordLike);
+          pieceKinds.push(currentKind);
+        }
+        currentText = ch;
+        currentKind = kind;
+      }
+    }
+    if (currentKind !== null) {
+      pieceTexts.push(currentText);
+      pieceWordLikes.push(currentKind === "text" && rawWordLike);
+      pieceKinds.push(currentKind);
+    }
+    pieces.push({ texts: pieceTexts, isWordLike: pieceWordLikes, kinds: pieceKinds });
+  }
+  return pieces;
+}
+function* fallbackSegmentWords(text) {
+  let index = 0;
+  let current = "";
+  let currentIndex = 0;
+  let currentWordLike = null;
+  const flush = () => {
+    if (current.length === 0 || currentWordLike === null) return void 0;
+    const out2 = { segment: current, index: currentIndex, isWordLike: currentWordLike };
+    current = "";
+    currentWordLike = null;
+    return out2;
+  };
+  for (const ch of text) {
+    const isWordLike = !/[\s\u200B\u00AD]/u.test(ch);
+    if (currentWordLike !== null && currentWordLike !== isWordLike) {
+      const out2 = flush();
+      if (out2) yield out2;
+    }
+    if (currentWordLike === null) {
+      currentWordLike = isWordLike;
+      currentIndex = index;
+    }
+    current += ch;
+    index += ch.length;
+  }
+  const out = flush();
+  if (out) yield out;
+}
+function* fallbackSegmentGraphemes(text) {
+  let index = 0;
+  for (const ch of text) {
+    yield { segment: ch, index };
+    index += ch.length;
+  }
+}
+function createDefaultSegmentAdapter() {
+  return {
+    segmentWords(text) {
+      return fallbackSegmentWords(text);
+    },
+    segmentGraphemes(text) {
+      return fallbackSegmentGraphemes(text);
+    }
+  };
+}
+var defaultSegmentAdapter = null;
+function getDefaultSegmentAdapter() {
+  if (defaultSegmentAdapter === null) {
+    defaultSegmentAdapter = createDefaultSegmentAdapter();
+  }
+  return defaultSegmentAdapter;
+}
+function measuredWidth(value) {
+  const width = typeof value === "number" ? value : value.width;
+  return Number.isFinite(width) && width >= 0 ? width : 0;
+}
+function metricKey(text, font) {
+  return `${font}\0${text}`;
+}
+var InjectedMeasureAdapter = class {
+  measure;
+  shouldCache;
+  cache = /* @__PURE__ */ new Map();
+  constructor(measure, opts = {}) {
+    this.measure = measure;
+    this.shouldCache = opts.cache ?? true;
+  }
+  measureSegment(text, font) {
+    const key = metricKey(text, font);
+    if (this.shouldCache) {
+      const cached = this.cache.get(key);
+      if (cached !== void 0) return { width: cached };
+    }
+    const width = measuredWidth(this.measure(text, font));
+    if (this.shouldCache) this.cache.set(key, width);
+    return { width };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+};
+var PrecomputedMeasureAdapter = class {
+  metrics;
+  fallback;
+  cellWidth;
+  constructor(opts) {
+    this.metrics = opts.metrics instanceof Map ? opts.metrics : new Map(Object.entries(opts.metrics));
+    this.fallback = opts.fallback ?? "error";
+    this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+  }
+  measureSegment(text, font) {
+    const fontScoped = this.metrics.get(metricKey(text, font));
+    if (fontScoped !== void 0) return { width: nonNegativeFinite(fontScoped, 0) };
+    const unscoped = this.metrics.get(text);
+    if (unscoped !== void 0) return { width: nonNegativeFinite(unscoped, 0) };
+    if (this.fallback === "per-char") {
+      return { width: Array.from(text).length * this.cellWidth };
+    }
+    throw new Error(`No precomputed metric for segment ${JSON.stringify(text)}`);
+  }
+};
+var CellMeasureAdapter = class {
+  cellWidth;
+  wideCellWidth;
+  tabCells;
+  constructor(opts = {}) {
+    this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+    this.wideCellWidth = nonNegativeFinite(
+      opts.wideCellWidth ?? this.cellWidth * 2,
+      this.cellWidth * 2
+    );
+    this.tabCells = Math.max(1, Math.floor(nonNegativeFinite(opts.tabCells ?? 4, 4)));
+  }
+  measureSegment(text) {
+    let width = 0;
+    for (const char of text) {
+      if (char === "	") width += this.cellWidth * this.tabCells;
+      else width += isCJK(char) ? this.wideCellWidth : this.cellWidth;
+    }
+    return { width };
+  }
+};
+var CapabilityMeasureAdapter = class {
+  capability;
+  constructor(capability) {
+    this.capability = capability;
+  }
+  measureSegment(text, font) {
+    return { width: measuredWidth(this.capability.measureText(text, font)) };
+  }
+  clearCache() {
+    this.capability.clearCache?.();
+  }
+};
+function stripSvgIgnoredContent(svg) {
+  return svg.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+}
+function readSvgRootTag(svg) {
+  return /<svg\b[^>]*>/i.exec(svg)?.[0] ?? null;
+}
+function readNumericAttr(tag, attr) {
+  const pattern = new RegExp(`(?:^|\\s)${attr}\\s*=\\s*["']?(-?\\d+(?:\\.\\d+)?)`, "i");
+  const match = pattern.exec(tag);
+  if (!match) return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readViewBox(tag) {
+  const match = /\bviewBox\s*=\s*["']\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*["']/i.exec(
+    tag
+  );
+  if (!match) return null;
+  const width = Number(match[3]);
+  const height = Number(match[4]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0) {
+    return null;
+  }
+  return { width, height };
+}
+var SvgBoundsAdapter = class {
+  measureSvg(svg) {
+    const cleaned = stripSvgIgnoredContent(svg);
+    const rootTag = readSvgRootTag(cleaned);
+    if (rootTag === null) throw new Error("Cannot measure SVG without a root <svg> element");
+    const width = readNumericAttr(rootTag, "width");
+    const height = readNumericAttr(rootTag, "height");
+    if (width !== null && height !== null) return { width, height };
+    const viewBox = readViewBox(rootTag);
+    if (viewBox) return viewBox;
+    throw new Error("Cannot measure SVG without width/height or viewBox");
+  }
+};
+var ImageSizeAdapter = class {
+  sizes;
+  constructor(sizes) {
+    this.sizes = isImageSizeLookup(sizes) ? sizes : new Map(Object.entries(sizes));
+  }
+  measureImage(src) {
+    const size = this.sizes.get(src);
+    if (!size) throw new Error(`No image size registered for ${JSON.stringify(src)}`);
+    return size;
+  }
+};
+function isImageSizeLookup(value) {
+  if (value === null) return false;
+  const valueType = typeof value;
+  if (valueType !== "object" && valueType !== "function") return false;
+  return typeof value.get === "function";
+}
+function measurementIssue(code, message, targetId, measurementKind, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: opts.severity ?? "warning",
+    source: opts.source,
+    subjectId: targetId,
+    measurementKind,
+    details: opts.details,
+    metadata: opts.metadata
+  };
+}
+function measurementOk(targetId, measurementKind, value, opts = {}) {
+  return {
+    kind: "ok",
+    targetId,
+    measurementKind,
+    value,
+    source: opts.source,
+    metadata: opts.metadata
+  };
+}
+function latestMeasurementValue(measurements, targetId, measurementKind) {
+  let value;
+  for (const fact of measurements) {
+    if (fact.kind === "ok" && fact.targetId === targetId && fact.measurementKind === measurementKind) {
+      value = fact.value;
+    }
+  }
+  return value;
+}
+function tryMeasureHyphenWidth(adapter, font) {
+  try {
+    return nonNegativeFinite(adapter.measureSegment("-", font).width, 0);
+  } catch {
+    return void 0;
+  }
+}
+function validMeasurementSize(size, label) {
+  if (!Number.isFinite(size.width) || !Number.isFinite(size.height) || size.width < 0 || size.height < 0) {
+    throw new Error(`Invalid ${label} measurement size`);
+  }
+  return size;
+}
+function textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source) {
+  try {
+    const segments = analyzeAndMeasure(text, font, adapter, cache, void 0, segmentAdapter);
+    const hyphenWidth = tryMeasureHyphenWidth(adapter, font);
+    const facts = [
+      measurementOk(
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        hyphenWidth === void 0 ? { segments } : { segments, hyphenWidth },
+        { source }
+      )
+    ];
+    if (hyphenWidth === void 0) {
+      facts.push(
+        measurementIssue(
+          "measurement.hyphen.failed",
+          `Hyphen measurement failed for '${targetId}'`,
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND,
+          { source, severity: "warning" }
+        )
+      );
+    }
+    return facts;
+  } catch (error) {
+    return [
+      measurementIssue(
+        "measurement.failed",
+        `Text measurement failed for '${targetId}'`,
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        { source, details: error, severity: "error" }
+      )
+    ];
+  }
+}
+function inputNode(g, input, fallback, name) {
+  if (input instanceof Node) {
+    return {
+      node: input,
+      set(value) {
+        const maybeState = input;
+        if (typeof maybeState.set !== "function") {
+          throw new TypeError(`reactive-layout input '${name}' is not a writable state node`);
+        }
+        maybeState.set(value);
+      }
+    };
+  }
+  const state = g.state(input ?? fallback, { name });
+  return { node: state, set: (value) => state.set(value) };
+}
+function scopedName(scope, local) {
+  return scope === local ? local : `${scope}:${local}`;
+}
+function textMeasurementProvider(opts) {
+  const targetId = opts.targetId ?? "text";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeAdapter = null;
+  return opts.graph.node(
+    opts.segmentAdapter ? [opts.text, opts.font, opts.adapter, opts.segmentAdapter] : [opts.text, opts.font, opts.adapter],
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        depLatest(ctx, 2).clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      const text = depLatest(ctx, 0);
+      const font = depLatest(ctx, 1);
+      const adapter = depLatest(ctx, 2);
+      if (adapter !== activeAdapter) {
+        cache.clear();
+        activeAdapter = adapter;
+      }
+      const segmentAdapter = opts.segmentAdapter === void 0 ? getDefaultSegmentAdapter() : depLatest(ctx, 3);
+      ctx.down([
+        [
+          "DATA",
+          textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source)
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function injectedTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(
+    new InjectedMeasureAdapter(opts.measure, { cache: opts.cache }),
+    {
+      name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+    }
+  );
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "injectedTextMeasurements"
+  });
+}
+function precomputedTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(new PrecomputedMeasureAdapter(opts), {
+    name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+  });
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "precomputedTextMeasurements"
+  });
+}
+function cellTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(new CellMeasureAdapter(opts), {
+    name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+  });
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "cellTextMeasurements"
+  });
+}
+function capabilityTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.node(
+    [opts.capability],
+    (ctx) => {
+      ctx.down([
+        ["DATA", new CapabilityMeasureAdapter(depLatest(ctx, 0))]
+      ]);
+    },
+    {
+      name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+    }
+  );
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "capabilityTextMeasurements"
+  });
+}
+function readinessTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeAdapter = null;
+  let activeReadiness = null;
+  const deps = opts.segmentAdapter ? [opts.text, opts.font, opts.adapter, opts.readiness, opts.segmentAdapter] : [opts.text, opts.font, opts.adapter, opts.readiness];
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        depLatest(ctx, 2).clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      const text = depLatest(ctx, 0);
+      const font = depLatest(ctx, 1);
+      const adapter = depLatest(ctx, 2);
+      if (adapter !== activeAdapter) {
+        cache.clear();
+        activeAdapter = adapter;
+      }
+      const readiness = depLatest(ctx, 3);
+      if (readiness !== activeReadiness) {
+        cache.clear();
+        activeReadiness = readiness;
+      }
+      if (!readiness.ready) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                readiness.code ?? "measurement.not-ready",
+                readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+                targetId,
+                TEXT_SEGMENTS_MEASUREMENT_KIND,
+                {
+                  source: readiness.source ?? source,
+                  details: readiness.details,
+                  metadata: readiness.metadata,
+                  severity: "warning"
+                }
+              )
+            ]
+          ]
+        ]);
+        return;
+      }
+      const segmentAdapter = opts.segmentAdapter === void 0 ? getDefaultSegmentAdapter() : depLatest(ctx, 4);
+      ctx.down([
+        [
+          "DATA",
+          textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source)
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function readinessMeasurements(opts) {
+  const targetId = opts.targetId ?? "measurement-readiness";
+  const measurementKind = opts.measurementKind ?? READINESS_MEASUREMENT_KIND;
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.readiness],
+    (ctx) => {
+      const readiness = depLatest(ctx, 0);
+      if (!readiness.ready) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                readiness.code ?? "measurement.not-ready",
+                readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+                targetId,
+                measurementKind,
+                {
+                  source: readiness.source ?? source,
+                  details: readiness.details,
+                  metadata: readiness.metadata,
+                  severity: "warning"
+                }
+              )
+            ]
+          ]
+        ]);
+        return;
+      }
+      ctx.down([
+        [
+          "DATA",
+          [
+            measurementOk(targetId, measurementKind, readiness, {
+              source: readiness.source ?? source,
+              metadata: readiness.metadata
+            })
+          ]
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function imageSizeMeasurements(opts) {
+  const measurementKind = opts.measurementKind ?? IMAGE_SIZE_MEASUREMENT_KIND;
+  const name = opts.name ?? "image-size-measurements";
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.images, opts.measurer],
+    (ctx) => {
+      const images = depLatest(ctx, 0);
+      const measurer = depLatest(ctx, 1);
+      const facts = [];
+      for (let i = 0; i < images.length; i += 1) {
+        const image = images[i];
+        const subjectId = image?.id ?? image?.src ?? `image:${i}`;
+        try {
+          if (image === void 0) throw new Error(`Missing image target at index ${i}`);
+          facts.push(
+            measurementOk(
+              subjectId,
+              measurementKind,
+              validMeasurementSize(measurer.measureImage(image.src), "image"),
+              {
+                source,
+                metadata: image.metadata
+              }
+            )
+          );
+        } catch (error) {
+          facts.push(
+            measurementIssue(
+              "measurement.image-size.failed",
+              `Image size measurement failed for '${subjectId}'`,
+              subjectId,
+              measurementKind,
+              {
+                source,
+                details: { error, index: i, src: image?.src },
+                metadata: image?.metadata,
+                severity: "error"
+              }
+            )
+          );
+        }
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name }
+  );
+}
+function svgBoundsMeasurements(opts) {
+  const measurementKind = opts.measurementKind ?? SVG_BOUNDS_MEASUREMENT_KIND;
+  const name = opts.name ?? "svg-bounds-measurements";
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.svgs, opts.measurer],
+    (ctx) => {
+      const svgs = depLatest(ctx, 0);
+      const measurer = depLatest(ctx, 1);
+      const facts = [];
+      for (let i = 0; i < svgs.length; i += 1) {
+        const svg = svgs[i];
+        const subjectId = svg?.id ?? `svg:${i}`;
+        try {
+          if (svg === void 0) throw new Error(`Missing SVG target at index ${i}`);
+          facts.push(
+            measurementOk(
+              subjectId,
+              measurementKind,
+              validMeasurementSize(measurer.measureSvg(svg.svg), "SVG"),
+              {
+                source,
+                metadata: svg.metadata
+              }
+            )
+          );
+        } catch (error) {
+          facts.push(
+            measurementIssue(
+              "measurement.svg-bounds.failed",
+              `SVG bounds measurement failed for '${subjectId}'`,
+              subjectId,
+              measurementKind,
+              {
+                source,
+                details: { error, index: i },
+                metadata: svg?.metadata,
+                severity: "error"
+              }
+            )
+          );
+        }
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name }
+  );
+}
+function mergeMeasurements(opts) {
+  const sources = [...opts.sources];
+  return opts.graph.node(
+    sources,
+    (ctx) => {
+      const facts = [];
+      for (let i = 0; i < sources.length; i += 1) {
+        facts.push(...depLatest(ctx, i));
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name: opts.name ?? "measurements" }
+  );
+}
+function blockAdaptersProvider(opts) {
+  const deps = [];
+  const positions = {};
+  if (opts.text) {
+    positions.text = deps.length;
+    deps.push(opts.text);
+  }
+  if (opts.svg) {
+    positions.svg = deps.length;
+    deps.push(opts.svg);
+  }
+  if (opts.image) {
+    positions.image = deps.length;
+    deps.push(opts.image);
+  }
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const adapters = {
+        text: positions.text === void 0 ? void 0 : depLatest(ctx, positions.text),
+        svg: positions.svg === void 0 ? void 0 : depLatest(ctx, positions.svg),
+        image: positions.image === void 0 ? void 0 : depLatest(ctx, positions.image)
+      };
+      ctx.down([["DATA", adapters]]);
+    },
+    { name: opts.name ?? "block-adapters" }
+  );
+}
+function blockMeasurementProvider(opts) {
+  const targetId = opts.targetId ?? "blocks";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeTextAdapter;
+  const deps = [opts.blocks, opts.maxWidth, opts.adapters];
+  if (opts.font) deps.push(opts.font);
+  if (opts.lineHeight) deps.push(opts.lineHeight);
+  if (opts.segmentAdapter) deps.push(opts.segmentAdapter);
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        const adapters = depLatest(ctx, 2);
+        adapters.text?.clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      try {
+        const blocks = depLatest(ctx, 0);
+        const maxWidth = nonNegativeFinite(depLatest(ctx, 1), 0);
+        const adapters = depLatest(ctx, 2);
+        if (adapters.text !== activeTextAdapter) {
+          cache.clear();
+          activeTextAdapter = adapters.text;
+        }
+        let depIndex = 3;
+        const font = opts.font ? depLatest(ctx, depIndex++) : void 0;
+        const lineHeight = opts.lineHeight ? nonNegativeFinite(depLatest(ctx, depIndex++), 0) : void 0;
+        const segmentAdapter = opts.segmentAdapter ? depLatest(ctx, depIndex) : getDefaultSegmentAdapter();
+        const measured = [];
+        const issues = [];
+        for (let i = 0; i < blocks.length; i += 1) {
+          const block = blocks[i];
+          const subjectId = block?.id ?? `${targetId}:${i}`;
+          try {
+            if (block === void 0) {
+              throw new Error(`Missing content block at index ${i}`);
+            }
+            const blockFont = block.kind === "text" ? block.font ?? font ?? "16px sans-serif" : void 0;
+            const hyphenWidth = block.kind === "text" && adapters.text ? tryMeasureHyphenWidth(adapters.text, blockFont ?? "16px sans-serif") : void 0;
+            measured.push(
+              measureBlock(block, {
+                adapters,
+                font,
+                hyphenWidth,
+                lineHeight,
+                maxWidth,
+                cache,
+                segmentAdapter
+              })
+            );
+            if (block.kind === "text" && adapters.text) {
+              if (hyphenWidth === void 0) {
+                issues.push(
+                  measurementIssue(
+                    "measurement.hyphen.failed",
+                    `Hyphen measurement failed for '${subjectId}'`,
+                    subjectId,
+                    BLOCKS_MEASUREMENT_KIND,
+                    {
+                      source,
+                      details: { targetId, index: i },
+                      severity: "warning"
+                    }
+                  )
+                );
+              }
+            }
+          } catch (error) {
+            issues.push(
+              measurementIssue(
+                "measurement.block.failed",
+                `Block measurement failed for '${subjectId}'`,
+                subjectId,
+                BLOCKS_MEASUREMENT_KIND,
+                {
+                  source,
+                  details: { error, targetId, index: i, blockKind: block?.kind },
+                  severity: "error"
+                }
+              )
+            );
+          }
+        }
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementOk(
+                targetId,
+                BLOCKS_MEASUREMENT_KIND,
+                { blocks: measured },
+                { source }
+              ),
+              ...issues
+            ]
+          ]
+        ]);
+      } catch (error) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                "measurement.failed",
+                `Block measurement failed for '${targetId}'`,
+                targetId,
+                BLOCKS_MEASUREMENT_KIND,
+                { source, details: error, severity: "error" }
+              )
+            ]
+          ]
+        ]);
+      }
+    },
+    { name }
+  );
+}
+function analyzeAndMeasure(text, font, adapter, cache, stats, segmentAdapter) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length === 0) {
+    return [];
+  }
+  const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+  const pieces = segmentText(normalized, segAdapter);
+  const rawTexts = [];
+  const rawKinds = [];
+  const rawWordLike = [];
+  for (const piece of pieces) {
+    for (let i = 0; i < piece.texts.length; i += 1) {
+      rawTexts.push(piece.texts[i]);
+      rawKinds.push(piece.kinds[i]);
+      rawWordLike.push(piece.isWordLike[i]);
+    }
+  }
+  const mergedTexts = [];
+  const mergedKinds = [];
+  const mergedWordLike = [];
+  for (let i = 0; i < rawTexts.length; i += 1) {
+    const t = rawTexts[i];
+    const k = rawKinds[i];
+    const wl = rawWordLike[i];
+    if (k === "text" && !wl && mergedTexts.length > 0 && mergedKinds[mergedTexts.length - 1] === "text") {
+      const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
+      if (isSticky) {
+        mergedTexts[mergedTexts.length - 1] += t;
+        continue;
+      }
+    }
+    if (t === "-" && mergedTexts.length > 0 && mergedKinds[mergedKinds.length - 1] === "text" && mergedWordLike[mergedWordLike.length - 1]) {
+      mergedTexts[mergedTexts.length - 1] += t;
+      continue;
+    }
+    mergedTexts.push(t);
+    mergedKinds.push(k);
+    mergedWordLike.push(wl);
+  }
+  const fontCache = cache.get(font) ?? /* @__PURE__ */ new Map();
+  if (!cache.has(font)) cache.set(font, fontCache);
+  function measureCached(segment) {
+    const cached = fontCache.get(segment);
+    if (cached === void 0) {
+      if (stats) stats.misses += 1;
+      const measured = adapter.measureSegment(segment, font).width;
+      const width = Number.isFinite(measured) && measured >= 0 ? measured : 0;
+      fontCache.set(segment, width);
+      return width;
+    }
+    if (stats) stats.hits += 1;
+    return cached;
+  }
+  const out = [];
+  for (let i = 0; i < mergedTexts.length; i += 1) {
+    const t = mergedTexts[i];
+    const kind = mergedKinds[i];
+    if (kind !== "text") {
+      out.push({
+        text: t,
+        width: kind === "space" ? measureCached(" ") * t.length : 0,
+        kind,
+        graphemeWidths: null
+      });
+      continue;
+    }
+    if (isCJK(t)) {
+      let unitText = "";
+      for (const graphemeSegment of segAdapter.segmentGraphemes(t)) {
+        const grapheme = graphemeSegment.segment;
+        if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
+          unitText += grapheme;
+          continue;
+        }
+        if (unitText.length > 0) {
+          out.push({
+            text: unitText,
+            width: measureCached(unitText),
+            kind: "text",
+            graphemeWidths: null
+          });
+        }
+        unitText = grapheme;
+      }
+      if (unitText.length > 0) {
+        out.push({
+          text: unitText,
+          width: measureCached(unitText),
+          kind: "text",
+          graphemeWidths: null
+        });
+      }
+      continue;
+    }
+    const textWidth = measureCached(t);
+    let graphemeWidths = null;
+    if (mergedWordLike[i] && t.length > 1) {
+      const widths = [];
+      for (const grapheme of segAdapter.segmentGraphemes(t)) {
+        widths.push(measureCached(grapheme.segment));
+      }
+      if (widths.length > 1) graphemeWidths = widths;
+    }
+    out.push({
+      text: t,
+      width: textWidth,
+      kind: "text",
+      graphemeWidths
+    });
+  }
+  return out;
+}
+function computeLineBreaks(segments, maxWidth, opts = {}) {
+  if (segments.length === 0) return { lines: [], lineCount: 0 };
+  const segAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  while (cursor.segmentIndex < segments.length) {
+    const next = layoutNextLine(segments, cursor, maxWidth, {
+      hyphenWidth: opts.hyphenWidth,
+      segmentAdapter: segAdapter
+    });
+    if (next === null) break;
+    lines.push({
+      text: next.text,
+      width: next.width,
+      startSegment: next.start.segmentIndex,
+      startGrapheme: next.start.graphemeIndex,
+      endSegment: next.end.segmentIndex,
+      endGrapheme: next.end.graphemeIndex
+    });
+    if (next.end.segmentIndex === cursor.segmentIndex && next.end.graphemeIndex === cursor.graphemeIndex) {
+      break;
+    }
+    cursor = next.end;
+  }
+  return { lines, lineCount: lines.length };
+}
+function canBreakAfter(kind) {
+  return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+function sliceSegmentText(seg, startGrapheme, endGrapheme, segmentAdapter) {
+  if (startGrapheme === 0 && endGrapheme < 0) return seg.text;
+  const graphemes = [...segmentAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+  const stop = endGrapheme < 0 ? graphemes.length : endGrapheme;
+  return graphemes.slice(startGrapheme, stop).join("");
+}
+function buildLineText(segments, startSegment, startGrapheme, endSegment, endGrapheme, appendHyphen, segmentAdapter) {
+  let text = "";
+  for (let i = startSegment; i < endSegment; i += 1) {
+    const seg = segments[i];
+    if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+    if (i === startSegment && startGrapheme > 0) {
+      text += sliceSegmentText(seg, startGrapheme, -1, segmentAdapter);
+    } else {
+      text += seg.text;
+    }
+  }
+  if (endGrapheme > 0 && endSegment < segments.length) {
+    const seg = segments[endSegment];
+    const from = startSegment === endSegment ? startGrapheme : 0;
+    text += sliceSegmentText(seg, from, endGrapheme, segmentAdapter);
+  }
+  if (appendHyphen) text += "-";
+  return text;
+}
+function resolveHyphenWidth(ctx) {
+  if (ctx?.hyphenWidth !== void 0) return nonNegativeFinite(ctx.hyphenWidth, 0);
+  if (ctx?.adapter === void 0 || ctx.font === void 0) return 0;
+  const cache = ctx.cache;
+  if (cache) {
+    let fontCache = cache.get(ctx.font);
+    if (fontCache === void 0) {
+      fontCache = /* @__PURE__ */ new Map();
+      cache.set(ctx.font, fontCache);
+    }
+    let width = fontCache.get("-");
+    if (width === void 0) {
+      width = ctx.adapter.measureSegment("-", ctx.font).width;
+      fontCache.set("-", width);
+    }
+    return width;
+  }
+  return ctx.adapter.measureSegment("-", ctx.font).width;
+}
+function layoutNextLine(segments, cursor, slotWidth, ctx) {
+  let i = cursor.segmentIndex;
+  const initialGrapheme = cursor.graphemeIndex;
+  const segmentAdapter = ctx?.segmentAdapter ?? getDefaultSegmentAdapter();
+  if (i >= segments.length) return null;
+  if (initialGrapheme === 0) {
+    while (i < segments.length) {
+      const seg = segments[i];
+      if (seg.kind === "hard-break") {
+        return {
+          text: "",
+          width: 0,
+          start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
+        i += 1;
+        continue;
+      }
+      break;
+    }
+    if (i >= segments.length) return null;
+  }
+  const hyphenWidth = resolveHyphenWidth(ctx);
+  const startSegment = i;
+  const startGrapheme = i === cursor.segmentIndex ? initialGrapheme : 0;
+  let lineW = 0;
+  let lineEndSegment = startSegment;
+  let lineEndGrapheme = 0;
+  let hasContent = false;
+  let pendingBreakSegment = -1;
+  let pendingBreakGrapheme = 0;
+  let pendingBreakWidth = 0;
+  let pendingBreakSoftHyphen = false;
+  const recordPending = (sIdx, gIdx, width, kind) => {
+    pendingBreakSegment = sIdx;
+    pendingBreakGrapheme = gIdx;
+    pendingBreakWidth = width;
+    pendingBreakSoftHyphen = kind === "soft-hyphen";
+  };
+  const consumeBreakable = (segIdx, startG, widths) => {
+    for (let g = startG; g < widths.length; g += 1) {
+      const gw = widths[g];
+      if (!hasContent) {
+        lineW = gw;
+        lineEndSegment = segIdx;
+        lineEndGrapheme = g + 1;
+        hasContent = true;
+        continue;
+      }
+      if (lineW + gw > slotWidth + 1e-3) {
+        return true;
+      }
+      lineW += gw;
+      lineEndSegment = segIdx;
+      lineEndGrapheme = g + 1;
+    }
+    if (lineEndSegment === segIdx && lineEndGrapheme === widths.length) {
+      lineEndSegment = segIdx + 1;
+      lineEndGrapheme = 0;
+    }
+    return false;
+  };
+  if (startGrapheme > 0 && startSegment < segments.length) {
+    const seg = segments[startSegment];
+    if (seg.graphemeWidths) {
+      const overflow = consumeBreakable(startSegment, startGrapheme, seg.graphemeWidths);
+      if (overflow) {
+        const text2 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          false,
+          segmentAdapter
+        );
+        return {
+          text: text2,
+          width: lineW,
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      i = lineEndSegment;
+    }
+  }
+  for (; i < segments.length; i += 1) {
+    const seg = segments[i];
+    if (seg.kind === "hard-break") {
+      if (hasContent) {
+        const endsAtSoftHyphen2 = lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+        const text2 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          endsAtSoftHyphen2,
+          segmentAdapter
+        );
+        return {
+          text: text2,
+          width: lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      return {
+        text: "",
+        width: 0,
+        start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+        end: { segmentIndex: i + 1, graphemeIndex: 0 }
+      };
+    }
+    const w = seg.width;
+    if (!hasContent) {
+      if (w > slotWidth && seg.graphemeWidths) {
+        const overflow = consumeBreakable(i, 0, seg.graphemeWidths);
+        if (overflow) {
+          const text2 = buildLineText(
+            segments,
+            startSegment,
+            startGrapheme,
+            lineEndSegment,
+            lineEndGrapheme,
+            false,
+            segmentAdapter
+          );
+          return {
+            text: text2,
+            width: lineW,
+            start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+            end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+          };
+        }
+        i = lineEndSegment - 1;
+        continue;
+      }
+      lineW = w;
+      lineEndSegment = i + 1;
+      lineEndGrapheme = 0;
+      hasContent = true;
+      if (canBreakAfter(seg.kind)) {
+        recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+      }
+      continue;
+    }
+    const projectedWidth = lineW + w;
+    if (projectedWidth > slotWidth + 1e-3) {
+      if (canBreakAfter(seg.kind)) {
+        lineEndSegment = i + 1;
+        lineEndGrapheme = 0;
+        const endsAtSoftHyphen2 = seg.kind === "soft-hyphen";
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          endsAtSoftHyphen2,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      if (pendingBreakSegment >= 0) {
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          pendingBreakSegment,
+          pendingBreakGrapheme,
+          pendingBreakSoftHyphen,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: pendingBreakSegment, graphemeIndex: pendingBreakGrapheme }
+        };
+      }
+      if (w > slotWidth && seg.graphemeWidths) {
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          false,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: lineW,
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      const text2 = buildLineText(
+        segments,
+        startSegment,
+        startGrapheme,
+        lineEndSegment,
+        lineEndGrapheme,
+        false,
+        segmentAdapter
+      );
+      return {
+        text: text2,
+        width: lineW,
+        start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+        end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+      };
+    }
+    lineW = projectedWidth;
+    lineEndSegment = i + 1;
+    lineEndGrapheme = 0;
+    if (canBreakAfter(seg.kind)) {
+      recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+    }
+  }
+  if (!hasContent) return null;
+  const endsAtSoftHyphen = lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+  const text = buildLineText(
+    segments,
+    startSegment,
+    startGrapheme,
+    lineEndSegment,
+    lineEndGrapheme,
+    endsAtSoftHyphen,
+    segmentAdapter
+  );
+  return {
+    text,
+    width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+    start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+    end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+  };
+}
+function carveTextLineSlots(base, blocked, minSlotWidth = 0) {
+  let slots = [base];
+  for (const block of blocked) {
+    const next = [];
+    for (const slot of slots) {
+      if (block.right <= slot.left || block.left >= slot.right) {
+        next.push(slot);
+        continue;
+      }
+      if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
+      if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
+    }
+    slots = next;
+  }
+  if (minSlotWidth > 0) return slots.filter((slot) => slot.right - slot.left >= minSlotWidth);
+  return slots;
+}
+function computeCharPositions(lineBreaks, segments, lineHeight, segmentAdapter) {
+  const positions = [];
+  const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+  for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx += 1) {
+    const line = lineBreaks.lines[lineIdx];
+    const y = lineIdx * lineHeight;
+    let x = 0;
+    for (let si = line.startSegment; si < segments.length; si += 1) {
+      const seg = segments[si];
+      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
+        if (si >= line.endSegment && line.endGrapheme === 0) break;
+        continue;
+      }
+      const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+      if (graphemes.length === 0) continue;
+      const startGrapheme = si === line.startSegment ? line.startGrapheme : 0;
+      let endGrapheme;
+      if (si < line.endSegment) {
+        endGrapheme = graphemes.length;
+      } else if (si === line.endSegment && line.endGrapheme > 0) {
+        endGrapheme = line.endGrapheme;
+      } else {
+        break;
+      }
+      for (let g = startGrapheme; g < endGrapheme; g += 1) {
+        const width = seg.graphemeWidths ? seg.graphemeWidths[g] : seg.width / graphemes.length;
+        positions.push({ x, y, width, height: lineHeight, line: lineIdx });
+        x += width;
+      }
+    }
+  }
+  return positions;
+}
+function nonNegativeFinite(value, fallback) {
+  return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+function finiteNumber(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function emitLayoutError(ctx, error, fallback) {
+  ctx.down([["ERROR", errorPayload(error, fallback)]]);
+}
+function positiveFinite(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function clampDimension(value) {
+  return nonNegativeFinite(value ?? 0, 0);
+}
+function fitSize(size, maxWidth) {
+  const width = nonNegativeFinite(size.width, 0);
+  const height = nonNegativeFinite(size.height, 0);
+  if (width === 0 || maxWidth <= 0 || width <= maxWidth) return { width, height };
+  const scale = maxWidth / width;
+  return { width: maxWidth, height: height * scale };
+}
+function blockMaxWidth(blockMaxWidth2, maxWidth) {
+  const own = blockMaxWidth2 === void 0 ? maxWidth : nonNegativeFinite(blockMaxWidth2, maxWidth);
+  if (maxWidth <= 0) return own;
+  if (own <= 0) return maxWidth;
+  return Math.min(own, maxWidth);
+}
+function resolveTextAdapter(opts) {
+  const adapter = opts.adapters?.text ?? opts.adapter;
+  if (!adapter) throw new Error("Text blocks require a MeasurementAdapter");
+  return adapter;
+}
+function measureBlock(block, opts) {
+  const maxWidth = nonNegativeFinite(opts.maxWidth ?? 800, 800);
+  const marginTop = nonNegativeFinite(block.marginTop ?? 0, 0);
+  const marginBottom = nonNegativeFinite(block.marginBottom ?? 0, 0);
+  if (block.kind === "text") {
+    const adapter = resolveTextAdapter(opts);
+    const font = block.font ?? opts.font ?? "16px sans-serif";
+    const lineHeight = positiveFinite(block.lineHeight ?? opts.lineHeight ?? 20, 20);
+    const cache = opts.cache ?? /* @__PURE__ */ new Map();
+    const width = blockMaxWidth(block.maxWidth, maxWidth);
+    const segments = analyzeAndMeasure(
+      block.text,
+      font,
+      adapter,
+      cache,
+      void 0,
+      opts.segmentAdapter
+    );
+    const hyphenWidth = Object.hasOwn(opts, "hyphenWidth") ? opts.hyphenWidth : tryMeasureHyphenWidth(adapter, font);
+    const lineBreaks = computeLineBreaks(segments, width, {
+      hyphenWidth,
+      segmentAdapter: opts.segmentAdapter
+    });
+    const charPositions = computeCharPositions(
+      lineBreaks,
+      segments,
+      lineHeight,
+      opts.segmentAdapter
+    );
+    return {
+      block,
+      kind: block.kind,
+      id: block.id,
+      width: lineBreaks.lines.reduce((acc, line) => Math.max(acc, line.width), 0),
+      height: lineBreaks.lineCount * lineHeight,
+      marginTop,
+      marginBottom,
+      segments,
+      lineBreaks,
+      charPositions
+    };
+  }
+  if (block.kind === "image") {
+    const explicit2 = block.width !== void 0 && block.height !== void 0 ? { width: clampDimension(block.width), height: clampDimension(block.height) } : opts.adapters?.image?.measureImage(block.src);
+    if (!explicit2) throw new Error("Image blocks require width/height or an ImageMeasurer");
+    const size2 = fitSize(explicit2, blockMaxWidth(block.maxWidth, maxWidth));
+    return {
+      block,
+      kind: block.kind,
+      id: block.id,
+      width: size2.width,
+      height: size2.height,
+      marginTop,
+      marginBottom
+    };
+  }
+  const explicit = block.width !== void 0 && block.height !== void 0 ? { width: clampDimension(block.width), height: clampDimension(block.height) } : opts.adapters?.svg?.measureSvg(block.svg);
+  if (!explicit) throw new Error("SVG blocks require width/height or a SvgMeasurer");
+  const size = fitSize(explicit, blockMaxWidth(block.maxWidth, maxWidth));
+  return {
+    block,
+    kind: block.kind,
+    id: block.id,
+    width: size.width,
+    height: size.height,
+    marginTop,
+    marginBottom
+  };
+}
+function measureBlocks(blocks, opts) {
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  return blocks.map((block) => measureBlock(block, { ...opts, cache }));
+}
+function computeBlockFlow(blocks, gap = 0) {
+  const spacing = nonNegativeFinite(gap, 0);
+  let y = 0;
+  return blocks.map((block) => {
+    y += block.marginTop;
+    const positioned = { ...block, x: 0, y };
+    y += block.height + block.marginBottom + spacing;
+    return positioned;
+  });
+}
+function computeTotalHeight(blocks) {
+  if (blocks.length === 0) return 0;
+  let bottom = 0;
+  for (const block of blocks) {
+    bottom = Math.max(bottom, block.y + block.height + block.marginBottom);
+  }
+  return bottom;
+}
+function columnGeometry(container, columns) {
+  const paddingX = nonNegativeFinite(container.paddingX ?? 0, 0);
+  const paddingY = nonNegativeFinite(container.paddingY ?? 0, 0);
+  const count = Math.max(1, Math.floor(nonNegativeFinite(columns?.count ?? 1, 1)));
+  const gap = nonNegativeFinite(columns?.gap ?? 0, 0);
+  const width = nonNegativeFinite(container.width, 0);
+  const height = nonNegativeFinite(container.height, 0);
+  const innerWidth = Math.max(0, width - paddingX * 2 - gap * (count - 1));
+  const columnWidth = count > 0 ? innerWidth / count : 0;
+  return { paddingX, paddingY, count, gap, width, height, columnWidth };
+}
+function sanitizeFlowContainer(container) {
+  return {
+    width: nonNegativeFinite(container.width, 0),
+    height: nonNegativeFinite(container.height, 0),
+    paddingX: container.paddingX === void 0 ? void 0 : nonNegativeFinite(container.paddingX, 0),
+    paddingY: container.paddingY === void 0 ? void 0 : nonNegativeFinite(container.paddingY, 0)
+  };
+}
+function sanitizeFlowColumns(columns) {
+  return {
+    count: columns.count === void 0 ? void 0 : Math.max(1, Math.floor(nonNegativeFinite(columns.count, 1))),
+    gap: columns.gap === void 0 ? void 0 : nonNegativeFinite(columns.gap, 0)
+  };
+}
+function sanitizeObstacles(obstacles) {
+  return obstacles.map((obstacle) => {
+    if (obstacle.kind === "circle") {
+      return {
+        kind: obstacle.kind,
+        cx: finiteNumber(obstacle.cx, 0),
+        cy: finiteNumber(obstacle.cy, 0),
+        r: nonNegativeFinite(obstacle.r, 0)
+      };
+    }
+    return {
+      kind: obstacle.kind,
+      x: finiteNumber(obstacle.x, 0),
+      y: finiteNumber(obstacle.y, 0),
+      width: nonNegativeFinite(obstacle.width, 0),
+      height: nonNegativeFinite(obstacle.height, 0)
+    };
+  });
+}
+function circleIntervalForBand(obstacle, bandTop, bandBottom) {
+  const radius = nonNegativeFinite(obstacle.r, 0);
+  const centerY = obstacle.cy;
+  const nearestY = Math.max(bandTop, Math.min(centerY, bandBottom));
+  const dy = nearestY - centerY;
+  if (Math.abs(dy) > radius) return null;
+  const dx = Math.sqrt(Math.max(0, radius * radius - dy * dy));
+  return { left: obstacle.cx - dx, right: obstacle.cx + dx };
+}
+function rectIntervalForBand(obstacle, bandTop, bandBottom) {
+  const left = obstacle.x;
+  const right = obstacle.x + nonNegativeFinite(obstacle.width, 0);
+  const top = obstacle.y;
+  const bottom = obstacle.y + nonNegativeFinite(obstacle.height, 0);
+  if (bottom <= bandTop || top >= bandBottom || right <= left) return null;
+  return { left, right };
+}
+function blockedIntervalsForBand(obstacles, bandTop, bandBottom) {
+  const intervals = [];
+  for (const obstacle of obstacles) {
+    const interval = obstacle.kind === "circle" ? circleIntervalForBand(obstacle, bandTop, bandBottom) : rectIntervalForBand(obstacle, bandTop, bandBottom);
+    if (interval) intervals.push(interval);
+  }
+  return intervals.sort((a, b) => a.left - b.left);
+}
+function computeFlowLines(segments, opts) {
+  const geometry = columnGeometry(opts.container, opts.columns);
+  const lineHeight = positiveFinite(opts.lineHeight, 20);
+  const minSlotWidth = nonNegativeFinite(opts.minSlotWidth ?? 0, 0);
+  const obstacles = opts.obstacles ?? [];
+  const segmentAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  const contentBottom = Math.max(geometry.paddingY, geometry.height - geometry.paddingY);
+  for (let columnIndex = 0; columnIndex < geometry.count; columnIndex += 1) {
+    const columnLeft = geometry.paddingX + columnIndex * (geometry.columnWidth + geometry.gap);
+    const columnRight = columnLeft + geometry.columnWidth;
+    for (let y = geometry.paddingY; y + lineHeight <= contentBottom + 1e-3 && cursor.segmentIndex < segments.length; y += lineHeight) {
+      const blocked = blockedIntervalsForBand(obstacles, y, y + lineHeight);
+      const slots = carveTextLineSlots(
+        { left: columnLeft, right: columnRight },
+        blocked,
+        Math.max(minSlotWidth, 1e-6)
+      );
+      for (const slot of slots) {
+        if (cursor.segmentIndex >= segments.length) break;
+        const slotWidth = slot.right - slot.left;
+        const next = layoutNextLine(segments, cursor, slotWidth, {
+          hyphenWidth: opts.hyphenWidth,
+          segmentAdapter
+        });
+        if (next === null) {
+          cursor = { segmentIndex: segments.length, graphemeIndex: 0 };
+          break;
+        }
+        if (next.end.segmentIndex === cursor.segmentIndex && next.end.graphemeIndex === cursor.graphemeIndex) {
+          break;
+        }
+        cursor = next.end;
+        if (next.text.length === 0 && next.width === 0) break;
+        lines.push({
+          text: next.text,
+          width: next.width,
+          startSegment: next.start.segmentIndex,
+          startGrapheme: next.start.graphemeIndex,
+          endSegment: next.end.segmentIndex,
+          endGrapheme: next.end.graphemeIndex,
+          x: slot.left,
+          y,
+          slotWidth,
+          columnIndex
+        });
+      }
+    }
+  }
+  return {
+    lines,
+    cursor,
+    done: cursor.segmentIndex >= segments.length
+  };
+}
+function reactiveLayout(opts) {
+  const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-layout" } = opts;
+  const targetId = opts.targetId ?? "text";
+  const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+  const g = opts.graph;
+  const lineHeightInput = inputNode(
+    g,
+    opts.lineHeight instanceof Node ? opts.lineHeight : nonNegativeFinite(opts.lineHeight ?? 20, 20),
+    nonNegativeFinite(20, 20),
+    scopedName(name, "line-height")
+  );
+  const maxWidthInput = inputNode(
+    g,
+    opts.maxWidth instanceof Node ? opts.maxWidth : nonNegativeFinite(opts.maxWidth ?? 800, 800),
+    nonNegativeFinite(800, 800),
+    scopedName(name, "max-width")
+  );
+  const segments = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.segments ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout segments failed");
+      }
+    },
+    { name: scopedName(name, "segments") }
+  );
+  const lineBreaks = g.node(
+    [segments, maxWidthInput.node, measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 2),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        const computed = computeLineBreaks(
+          depLatest(ctx, 0),
+          nonNegativeFinite(depLatest(ctx, 1), 0),
+          { hyphenWidth: measured?.hyphenWidth, segmentAdapter: segAdapter }
+        );
+        ctx.down([["DATA", computed]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout line breaks failed");
+      }
+    },
+    { name: scopedName(name, "line-breaks") }
+  );
+  const height = g.node(
+    [lineBreaks, lineHeightInput.node],
+    (ctx) => {
+      try {
+        const lines = depLatest(ctx, 0);
+        const lineHeight = nonNegativeFinite(depLatest(ctx, 1), 0);
+        ctx.down([["DATA", lines.lineCount * lineHeight]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout height failed");
+      }
+    },
+    { name: scopedName(name, "height") }
+  );
+  const charPositions = g.node(
+    [lineBreaks, segments, lineHeightInput.node],
+    (ctx) => {
+      try {
+        const positions = computeCharPositions(
+          depLatest(ctx, 0),
+          depLatest(ctx, 1),
+          nonNegativeFinite(depLatest(ctx, 2), 0),
+          segAdapter
+        );
+        ctx.down([["DATA", positions]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout char positions failed");
+      }
+    },
+    { name: scopedName(name, "char-positions") }
+  );
+  return {
+    graph: g,
+    input: {
+      lineHeight: lineHeightInput.node,
+      maxWidth: maxWidthInput.node,
+      measurements
+    },
+    setLineHeight(lineHeight) {
+      lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+    },
+    setMaxWidth(maxWidth) {
+      maxWidthInput.set(nonNegativeFinite(maxWidth, 0));
+    },
+    segments,
+    lineBreaks,
+    height,
+    charPositions
+  };
+}
+function reactiveBlockLayout(opts) {
+  const { measurements, name = "reactive-block-layout" } = opts;
+  const targetId = opts.targetId ?? "blocks";
+  const g = opts.graph;
+  const gapInput = inputNode(
+    g,
+    opts.gap instanceof Node ? opts.gap : nonNegativeFinite(opts.gap ?? 0, 0),
+    nonNegativeFinite(0, 0),
+    scopedName(name, "gap")
+  );
+  const measuredBlocks = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          BLOCKS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.blocks ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout measured-blocks failed");
+      }
+    },
+    { name: scopedName(name, "measured-blocks") }
+  );
+  const blockFlow = g.node(
+    [measuredBlocks, gapInput.node],
+    (ctx) => {
+      try {
+        const positioned = computeBlockFlow(
+          depLatest(ctx, 0),
+          nonNegativeFinite(depLatest(ctx, 1), 0)
+        );
+        ctx.down([["DATA", positioned]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout flow failed");
+      }
+    },
+    { name: scopedName(name, "block-flow") }
+  );
+  const totalHeight = g.node(
+    [blockFlow],
+    (ctx) => {
+      try {
+        ctx.down([["DATA", computeTotalHeight(depLatest(ctx, 0))]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout total height failed");
+      }
+    },
+    { name: scopedName(name, "total-height") }
+  );
+  return {
+    graph: g,
+    input: {
+      gap: gapInput.node,
+      measurements
+    },
+    setGap(gap) {
+      gapInput.set(nonNegativeFinite(gap, 0));
+    },
+    measuredBlocks,
+    blockFlow,
+    totalHeight
+  };
+}
+function reactiveFlowLayout(opts) {
+  const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-flow-layout" } = opts;
+  const targetId = opts.targetId ?? "text";
+  const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+  const g = opts.graph;
+  const lineHeightInput = inputNode(
+    g,
+    opts.lineHeight instanceof Node ? opts.lineHeight : nonNegativeFinite(opts.lineHeight ?? 20, 20),
+    nonNegativeFinite(20, 20),
+    scopedName(name, "line-height")
+  );
+  const containerInput = inputNode(
+    g,
+    opts.container,
+    { width: 800, height: 600 },
+    scopedName(name, "container")
+  );
+  const columnsInput = inputNode(
+    g,
+    opts.columns,
+    { count: 1, gap: 0 },
+    scopedName(name, "columns")
+  );
+  const obstaclesInput = inputNode(g, opts.obstacles, [], scopedName(name, "obstacles"));
+  const segments = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.segments ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveFlowLayout segments failed");
+      }
+    },
+    { name: scopedName(name, "segments") }
+  );
+  const flowLines = g.node(
+    [
+      segments,
+      lineHeightInput.node,
+      containerInput.node,
+      columnsInput.node,
+      obstaclesInput.node,
+      measurements
+    ],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 5),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        const computed = computeFlowLines(depLatest(ctx, 0), {
+          lineHeight: nonNegativeFinite(depLatest(ctx, 1), 0),
+          container: sanitizeFlowContainer(depLatest(ctx, 2)),
+          columns: sanitizeFlowColumns(depLatest(ctx, 3)),
+          obstacles: sanitizeObstacles(depLatest(ctx, 4)),
+          minSlotWidth: nonNegativeFinite(opts.minSlotWidth ?? 0, 0),
+          hyphenWidth: measured?.hyphenWidth,
+          segmentAdapter: segAdapter
+        });
+        ctx.down([["DATA", computed]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveFlowLayout flow lines failed");
+      }
+    },
+    { name: scopedName(name, "flow-lines") }
+  );
+  return {
+    graph: g,
+    input: {
+      lineHeight: lineHeightInput.node,
+      container: containerInput.node,
+      columns: columnsInput.node,
+      obstacles: obstaclesInput.node,
+      measurements
+    },
+    setLineHeight(lineHeight) {
+      lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+    },
+    setContainer(container) {
+      containerInput.set(container);
+    },
+    setColumns(columns) {
+      columnsInput.set(columns);
+    },
+    setObstacles(obstacles) {
+      obstaclesInput.set(obstacles);
+    },
+    segments,
+    flowLines
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLOCKS_MEASUREMENT_KIND,
+  CapabilityMeasureAdapter,
+  CellMeasureAdapter,
+  IMAGE_SIZE_MEASUREMENT_KIND,
+  ImageSizeAdapter,
+  InjectedMeasureAdapter,
+  PrecomputedMeasureAdapter,
+  READINESS_MEASUREMENT_KIND,
+  SVG_BOUNDS_MEASUREMENT_KIND,
+  SvgBoundsAdapter,
+  TEXT_SEGMENTS_MEASUREMENT_KIND,
+  analyzeAndMeasure,
+  blockAdaptersProvider,
+  blockMeasurementProvider,
+  capabilityTextMeasurements,
+  carveTextLineSlots,
+  cellTextMeasurements,
+  circleIntervalForBand,
+  computeBlockFlow,
+  computeCharPositions,
+  computeFlowLines,
+  computeLineBreaks,
+  computeTotalHeight,
+  imageSizeMeasurements,
+  injectedTextMeasurements,
+  layoutNextLine,
+  measureBlock,
+  measureBlocks,
+  mergeMeasurements,
+  precomputedTextMeasurements,
+  reactiveBlockLayout,
+  reactiveFlowLayout,
+  reactiveLayout,
+  readinessMeasurements,
+  readinessTextMeasurements,
+  rectIntervalForBand,
+  svgBoundsMeasurements,
+  textMeasurementProvider
+});
+//# sourceMappingURL=index.cjs.map