@modernrelay/orbit-core 0.2.0 → 0.13.6

package/dist/index.js

@@ -1,5 +1,5 @@
-import { DIAGNOSTIC_SAMPLE_CAP, deriveClusters, resolveClusterCenters, clusterCentroids } from './chunk-Z7FOEASL.js';
-export { DEFAULT_CLUSTER_CENTER_RADIUS, DEFAULT_LAYOUT_SEED, DIAGNOSTIC_SAMPLE_CAP, clusterCentroids, deriveClusters, generateClusterCenters, resolveClusterCenters } from './chunk-Z7FOEASL.js';
+import { DIAGNOSTIC_SAMPLE_CAP, encodeStringTable, collectTransfers, deriveClusters, resolveClusterCenters, clusterCentroids, EnvelopeSequencer, RequestLedger } from './chunk-FG6TQANI.js';
+export { DEFAULT_CLUSTER_CENTER_RADIUS, DEFAULT_LAYOUT_SEED, DIAGNOSTIC_SAMPLE_CAP, acceptColumnar, clusterCentroids, collectTransfers, decodeStringTable, deriveClusters, encodeStringTable, generateClusterCenters, judgeEpoch, resolveClusterCenters } from './chunk-FG6TQANI.js';
 import { createStore } from 'zustand/vanilla';
 
 // src/errors.ts
@@ -96,6 +96,10 @@ function validateSnapshot(snapshot) {
       record(invalidNode, `[${i}]`);
       continue;
     }
+    if (id.includes("\0")) {
+      record(invalidNode, `[${i}]`);
+      continue;
+    }
     if (nodeIndex.has(id)) {
       record(duplicateNode, id);
       continue;
@@ -154,7 +158,7 @@ function validateSnapshot(snapshot) {
     "invalid-node",
     "error",
     invalidNode,
-    `${invalidNode.count} node row(s) dropped: missing or non-string id`
+    `${invalidNode.count} node row(s) dropped: missing, non-string, or NUL-containing id`
   );
   pushDiagnostic(
     diagnostics,
@@ -1513,6 +1517,375 @@ function neighborsOf(adj, index) {
   }
   return adj.neighbors.subarray(adj.offsets[index], adj.offsets[index + 1]);
 }
+function buildIncidence(links, pointCount) {
+  if (!Number.isInteger(pointCount) || pointCount < 0) {
+    throw new RangeError(
+      `buildIncidence: pointCount must be a non-negative integer, got ${pointCount}`
+    );
+  }
+  if ((links.length & 1) !== 0) {
+    throw new RangeError(
+      `buildIncidence: links length must be even ([src, tgt] pairs), got ${links.length}`
+    );
+  }
+  const n = links.length;
+  const offsets = new Uint32Array(pointCount + 1);
+  for (let i = 0; i < n; i++) {
+    const p = links[i];
+    if (p >= pointCount) {
+      throw new RangeError(
+        `buildIncidence: link endpoint ${p} out of range (pointCount ${pointCount})`
+      );
+    }
+    offsets[p + 1] = offsets[p + 1] + 1;
+  }
+  for (let i = 1; i <= pointCount; i++) {
+    offsets[i] = offsets[i] + offsets[i - 1];
+  }
+  const edgeSlots = new Uint32Array(n);
+  const cursor = offsets.slice(0, pointCount);
+  for (let i = 0; i < n; i += 2) {
+    const edge = i >>> 1;
+    const a = links[i];
+    const b = links[i + 1];
+    const ca = cursor[a];
+    edgeSlots[ca] = edge;
+    cursor[a] = ca + 1;
+    const cb = cursor[b];
+    edgeSlots[cb] = edge;
+    cursor[b] = cb + 1;
+  }
+  return { offsets, edgeSlots };
+}
+function incidentEdgesOf(inc, index) {
+  const pointCount = inc.offsets.length - 1;
+  if (!Number.isInteger(index) || index < 0 || index >= pointCount) {
+    throw new RangeError(`incidentEdgesOf: index ${index} out of range (pointCount ${pointCount})`);
+  }
+  return inc.edgeSlots.subarray(inc.offsets[index], inc.offsets[index + 1]);
+}
+
+// src/alphaCompose.ts
+var IncrementalAlphaComposer = class {
+  bufA = null;
+  bufB = null;
+  staleA = [];
+  staleB = [];
+  /** Which buffer the NEXT nextBuffer() call returns (0 = A, 1 = B). */
+  next = 0;
+  // --- seed key ---
+  seededBase = null;
+  seededCount = -1;
+  seededDimAlpha = NaN;
+  seededEpoch = void 0;
+  /** Slots rewritten since the last resetStats (wave-5 gate instrument). */
+  slotsRewritten = 0;
+  /** Full reseeds performed (each is one O(n) masked pass over the pair). */
+  reseeds = 0;
+  resetStats() {
+    this.slotsRewritten = 0;
+    this.reseeds = 0;
+  }
+  /**
+   * True when the composer is seeded for exactly this (base, count,
+   * dimAlpha, extraEpoch) tuple; otherwise both buffers are rebuilt with a
+   * full masked pass and the stale lists reset. Object.is on the alpha
+   * handles the NaN sentinel.
+   */
+  ensureSeeded(base, count, dimAlpha, extraEpoch, alphaOf) {
+    if (this.seededBase === base && this.seededCount === count && Object.is(this.seededDimAlpha, dimAlpha) && this.seededEpoch === extraEpoch && this.bufA !== null && this.bufB !== null) {
+      return true;
+    }
+    this.reseeds += 1;
+    this.bufA = this.seedOne(base, count, alphaOf, this.bufA);
+    this.bufB = this.seedOne(base, count, alphaOf, this.bufB);
+    this.staleA.length = 0;
+    this.staleB.length = 0;
+    this.seededBase = base;
+    this.seededCount = count;
+    this.seededDimAlpha = dimAlpha;
+    this.seededEpoch = extraEpoch;
+    return false;
+  }
+  /** Record changed slots from one mask drain (call once per drain — the
+   * drain arrays are reused by the mask, so this copies them out). */
+  note(slots) {
+    for (let i = 0; i < slots.length; i += 1) {
+      this.staleA.push(slots[i]);
+      this.staleB.push(slots[i]);
+    }
+  }
+  /**
+   * Replay the target buffer's stale slots against the CURRENT mask state,
+   * swap, and return it. Same output semantics as the naive composer: the
+   * base RGB is untouched, alpha = base alpha × alphaOf(slot).
+   */
+  nextBuffer(base, alphaOf) {
+    const useA = this.next === 0;
+    const buf = useA ? this.bufA : this.bufB;
+    const stale = useA ? this.staleA : this.staleB;
+    for (let i = 0; i < stale.length; i += 1) {
+      const slot = stale[i];
+      buf[4 * slot + 3] = base[4 * slot + 3] * alphaOf(slot);
+      this.slotsRewritten += 1;
+    }
+    stale.length = 0;
+    this.next = useA ? 1 : 0;
+    return buf;
+  }
+  /** Drop the buffers entirely (scene teardown). */
+  reset() {
+    this.bufA = null;
+    this.bufB = null;
+    this.staleA.length = 0;
+    this.staleB.length = 0;
+    this.seededBase = null;
+    this.seededCount = -1;
+    this.seededDimAlpha = NaN;
+    this.seededEpoch = void 0;
+    this.next = 0;
+  }
+  seedOne(base, count, alphaOf, reuse) {
+    const out = reuse !== null && reuse.length === base.length ? reuse : new Float32Array(base.length);
+    out.set(base);
+    for (let i = 0; i < count; i += 1) {
+      const a = alphaOf(i);
+      if (a !== 1) out[4 * i + 3] = base[4 * i + 3] * a;
+    }
+    return out;
+  }
+};
+
+// src/perf.ts
+var PRESSURE_WINDOW_MS = 250;
+var DROPPED_FRAME_MS = 34;
+var SLEEP_GAP_MS = 250;
+var PressureSampler = class {
+  lastFrameAt = NaN;
+  windowStart = NaN;
+  windowSum = 0;
+  windowCount = 0;
+  ewma = NaN;
+  worst = 0;
+  frames = 0;
+  dropped = 0;
+  windows = 0;
+  idleWakeups = 0;
+  /**
+   * Record one onFrame tick. `settled` marks a tick that arrived while the
+   * scene was at rest (sim settled, no pending commit work) — the idle-
+   * wakeup counter, which reads 0 when the ADR-005 gated clock is honest.
+   */
+  noteFrame(timeMs, settled) {
+    this.frames += 1;
+    if (settled) this.idleWakeups += 1;
+    const prev = this.lastFrameAt;
+    this.lastFrameAt = timeMs;
+    if (Number.isNaN(prev)) {
+      this.windowStart = timeMs;
+      return;
+    }
+    const delta = timeMs - prev;
+    if (delta < 0) {
+      this.windowStart = timeMs;
+      this.windowSum = 0;
+      this.windowCount = 0;
+      return;
+    }
+    if (delta >= SLEEP_GAP_MS) {
+      this.closeWindow();
+      this.windowStart = timeMs;
+      return;
+    }
+    if (delta > this.worst) this.worst = delta;
+    if (delta >= DROPPED_FRAME_MS) this.dropped += 1;
+    this.windowSum += delta;
+    this.windowCount += 1;
+    if (timeMs - this.windowStart >= PRESSURE_WINDOW_MS) {
+      this.closeWindow();
+      this.windowStart = timeMs;
+    }
+  }
+  snapshot() {
+    return {
+      frameEwmaMs: this.ewma,
+      worstFrameMs: this.worst,
+      frames: this.frames,
+      droppedFrames: this.dropped,
+      windows: this.windows,
+      idleWakeups: this.idleWakeups
+    };
+  }
+  /** Zero the accumulated counters (EWMA and frame anchor survive — the
+   * smoothing is continuous; the counters are per-sample-period). */
+  resetCounters() {
+    this.worst = 0;
+    this.frames = 0;
+    this.dropped = 0;
+    this.windows = 0;
+    this.idleWakeups = 0;
+  }
+  closeWindow() {
+    if (this.windowCount === 0) return;
+    const mean = this.windowSum / this.windowCount;
+    this.windows += 1;
+    this.ewma = Number.isNaN(this.ewma) ? mean : this.ewma * 0.7 + mean * 0.3;
+    this.windowSum = 0;
+    this.windowCount = 0;
+  }
+};
+
+// src/degrade.ts
+var SCALE_LIMITS_DEFAULTS = Object.freeze({
+  domLabelNodes: 1e5,
+  pickingLinks: 25e4,
+  histogramBatchNodes: 5e5,
+  hysteresis: 0.1,
+  minimumDwellMs: 1e3,
+  resourceDegradationOrder: Object.freeze(["disable-transitions", "defer-images"])
+});
+var RESOURCE_STEPS = /* @__PURE__ */ new Set([
+  "disable-transitions",
+  "defer-images",
+  "uniform-link-style"
+]);
+function resolveScaleLimits(input) {
+  const warnings = [];
+  const out = { ...SCALE_LIMITS_DEFAULTS };
+  if (input === void 0) return { limits: out, warnings };
+  const num3 = (key) => {
+    const v = input[key];
+    if (v === void 0) return;
+    if (typeof v === "number" && Number.isFinite(v) && v >= 0) out[key] = v;
+    else warnings.push(`limits.${key} must be a non-negative finite number (got ${String(v)})`);
+  };
+  num3("domLabelNodes");
+  num3("pickingLinks");
+  num3("histogramBatchNodes");
+  num3("minimumDwellMs");
+  if (input.hysteresis !== void 0) {
+    const h = input.hysteresis;
+    if (typeof h === "number" && Number.isFinite(h) && h >= 0 && h < 1) out.hysteresis = h;
+    else warnings.push(`limits.hysteresis must be in [0, 1) (got ${String(h)})`);
+  }
+  if (input.resourceDegradationOrder !== void 0) {
+    const order = input.resourceDegradationOrder;
+    const valid = Array.isArray(order) && order.every((s) => RESOURCE_STEPS.has(s)) && new Set(order).size === order.length;
+    if (valid) out.resourceDegradationOrder = Object.freeze([...order]);
+    else {
+      warnings.push(
+        "limits.resourceDegradationOrder must be unique resource steps ('disable-transitions' | 'defer-images' | 'uniform-link-style')"
+      );
+    }
+  }
+  return { limits: Object.freeze(out), warnings };
+}
+var DegradeController = class {
+  constructor(limits, now) {
+    this.limits = limits;
+    this.now = now;
+  }
+  limits;
+  now;
+  steps = /* @__PURE__ */ new Map();
+  activeCache = Object.freeze([]);
+  isEngaged(step) {
+    return this.steps.get(step)?.engaged === true;
+  }
+  /** Stable frozen list for GraphPerfSnapshot.activeDegradations. */
+  activeSteps() {
+    return this.activeCache;
+  }
+  /**
+   * Edge-triggered count evaluation over the CURRENT visible counts.
+   * Returns the events to emit (empty when nothing crossed its band or a
+   * dwell is holding). Count-engaged steps disengage here; pressure- or
+   * resource-engaged steps do NOT auto-disengage on counts — their signal
+   * owns them (`clearPressure` / `releaseResourceSteps`).
+   */
+  evaluateCounts(visible) {
+    const events = [];
+    const counts = [
+      ["cap-dom-labels", visible.nodes, this.limits.domLabelNodes],
+      ["defer-link-picking", visible.edges, this.limits.pickingLinks],
+      ["batch-histograms", visible.nodes, this.limits.histogramBatchNodes]
+    ];
+    for (const [step, value, limit] of counts) {
+      const state = this.stateOf(step);
+      if (!state.engaged) {
+        if (value > limit && this.dwellOver(state)) {
+          events.push(this.transition(step, state, true, "count", visible));
+        }
+      } else if (state.reason === "count") {
+        if (value < limit * (1 - this.limits.hysteresis) && this.dwellOver(state)) {
+          events.push(this.transition(step, state, false, "count", visible));
+        }
+      }
+    }
+    return events;
+  }
+  /**
+   * Pressure trigger (frame or input): engage a step EARLIER than its count
+   * hint. No-op (null) when already engaged or dwell-held.
+   */
+  engageForPressure(step, reason, visible) {
+    const state = this.stateOf(step);
+    if (state.engaged || !this.dwellOver(state)) return null;
+    return this.transition(step, state, true, reason, visible);
+  }
+  /** Release a pressure-engaged step once its signal normalizes. */
+  clearPressure(step, visible) {
+    const state = this.stateOf(step);
+    if (!state.engaged) return null;
+    if (state.reason !== "frame-pressure" && state.reason !== "input-pressure") return null;
+    if (!this.dwellOver(state)) return null;
+    return this.transition(step, state, false, state.reason, visible);
+  }
+  /**
+   * Resource-admission trigger: engage the NEXT not-yet-engaged step in the
+   * declared order. Null when the order is exhausted — the caller must then
+   * REJECT before allocating (§17: never silently erase semantic styling).
+   */
+  engageNextResourceStep(visible) {
+    for (const step of this.limits.resourceDegradationOrder) {
+      const state = this.stateOf(step);
+      if (state.engaged) continue;
+      return this.transition(step, state, true, "resource-estimate", visible);
+    }
+    return null;
+  }
+  /** Release every resource-engaged step (pressure cleared / new budget). */
+  releaseResourceSteps(visible) {
+    const events = [];
+    for (const step of this.limits.resourceDegradationOrder) {
+      const state = this.stateOf(step);
+      if (state.engaged && state.reason === "resource-estimate") {
+        events.push(this.transition(step, state, false, "resource-estimate", visible));
+      }
+    }
+    return events;
+  }
+  stateOf(step) {
+    let state = this.steps.get(step);
+    if (state === void 0) {
+      state = { engaged: false, changedAt: -Infinity, reason: null };
+      this.steps.set(step, state);
+    }
+    return state;
+  }
+  dwellOver(state) {
+    return this.now() - state.changedAt >= this.limits.minimumDwellMs || state.changedAt === -Infinity;
+  }
+  transition(step, state, engaged, reason, visible) {
+    state.engaged = engaged;
+    state.changedAt = this.now();
+    state.reason = engaged ? reason : null;
+    const active = [];
+    for (const [s, st] of this.steps) if (st.engaged) active.push(s);
+    this.activeCache = Object.freeze(active);
+    return { step, engaged, reason, visible: { nodes: visible.nodes, edges: visible.edges } };
+  }
+};
 
 // src/linkPick.ts
 var MEDIAN_SAMPLE_CAP = 1024;
@@ -2492,8 +2865,8 @@ function buildEntries(nodes, fields) {
       fieldValues = [];
       fieldLowers = [];
       const attrs = node.attrs;
-      for (const field of fields) {
-        const raw = attrs?.[field];
+      for (const field2 of fields) {
+        const raw = attrs?.[field2];
         if (raw === void 0 || raw === null) continue;
         const value = String(raw);
         fieldValues.push(value);
@@ -2595,11 +2968,408 @@ function createLocalSearchService(getBase) {
   };
 }
 
+// src/columnar.ts
+function isColumnarSnapshot(input) {
+  return input.kind === "columnar";
+}
+var isTypedLength = (arr, n) => arr !== void 0 && arr.length === n;
+function checkStringColumn(col, rows, where, isIds, out) {
+  if (col === null || typeof col !== "object") {
+    out.push({ where, problem: "not-a-string-column", detail: "column missing or not an object" });
+    return;
+  }
+  if (col.kind !== "string" || !Array.isArray(col.dictionary) || !(col.codes instanceof Uint32Array)) {
+    out.push({ where, problem: "not-a-string-column", detail: 'expected {kind:"string", dictionary, codes}' });
+    return;
+  }
+  if (col.codes.length !== rows) {
+    const detached = col.codes.length === 0 && col.codes.buffer.byteLength === 0;
+    out.push({
+      where,
+      problem: "length-mismatch",
+      detail: detached ? `codes buffer is DETACHED (a bufferOwnership:'transfer' snapshot is single-use)` : `codes.length ${col.codes.length} !== length ${rows}`
+    });
+    return;
+  }
+  if (col.nulls !== void 0) {
+    if (col.nulls.length !== rows) {
+      out.push({
+        where,
+        problem: "nulls-length-mismatch",
+        detail: `nulls.length ${col.nulls.length} !== length ${rows}`
+      });
+    } else if (isIds) {
+      for (let i = 0; i < rows; i++) {
+        if (col.nulls[i] !== 0) {
+          out.push({ where, problem: "null-id", detail: `row ${i}: ids may not be null` });
+          break;
+        }
+      }
+    }
+  }
+  const dictSize = col.dictionary.length;
+  for (let i = 0; i < rows; i++) {
+    if (col.codes[i] >= dictSize) {
+      out.push({
+        where,
+        problem: "code-out-of-range",
+        detail: `row ${i}: code ${col.codes[i]} >= dictionary size ${dictSize}`
+      });
+      break;
+    }
+  }
+}
+function checkColumn(col, rows, where, out) {
+  if (col === null || typeof col !== "object") {
+    out.push({ where, problem: "bad-column-kind", detail: "column missing or not an object" });
+    return;
+  }
+  switch (col.kind) {
+    case "string":
+      checkStringColumn(col, rows, where, false, out);
+      return;
+    case "f64":
+    case "i32":
+    case "u32":
+    case "bool": {
+      if (!isTypedLength(col.data, rows)) {
+        out.push({
+          where,
+          problem: "length-mismatch",
+          detail: `data.length ${col.data?.length ?? "missing"} !== length ${rows}`
+        });
+      }
+      if (col.nulls !== void 0 && col.nulls.length !== rows) {
+        out.push({
+          where,
+          problem: "nulls-length-mismatch",
+          detail: `nulls.length ${col.nulls.length} !== length ${rows}`
+        });
+      }
+      return;
+    }
+    default:
+      out.push({
+        where,
+        problem: "bad-column-kind",
+        detail: `unknown column kind '${String(col.kind)}'`
+      });
+  }
+}
+function validateColumnarStructure(snapshot) {
+  const issues = [];
+  const nodeRows = snapshot.nodes?.length;
+  const edgeRows = snapshot.edges?.length;
+  if (!Number.isInteger(nodeRows) || nodeRows < 0) {
+    issues.push({ where: "nodes.length", problem: "bad-length", detail: String(nodeRows) });
+    return issues;
+  }
+  if (!Number.isInteger(edgeRows) || edgeRows < 0) {
+    issues.push({ where: "edges.length", problem: "bad-length", detail: String(edgeRows) });
+    return issues;
+  }
+  if (snapshot.nodes === null || typeof snapshot.nodes !== "object") {
+    issues.push({ where: "nodes", problem: "bad-length", detail: "nodes lane missing" });
+    return issues;
+  }
+  if (snapshot.edges === null || typeof snapshot.edges !== "object") {
+    issues.push({ where: "edges", problem: "bad-length", detail: "edges lane missing" });
+    return issues;
+  }
+  checkStringColumn(snapshot.nodes.ids, nodeRows, "nodes.ids", true, issues);
+  for (const [name, col] of Object.entries(snapshot.nodes.columns ?? {})) {
+    checkColumn(col, nodeRows, `nodes.${name}`, issues);
+  }
+  checkStringColumn(snapshot.edges.ids, edgeRows, "edges.ids", true, issues);
+  for (const [name, col] of Object.entries(snapshot.edges.columns ?? {})) {
+    checkColumn(col, edgeRows, `edges.${name}`, issues);
+  }
+  const { source, target } = snapshot.edges;
+  if (!(source instanceof Uint32Array) || source.length !== edgeRows) {
+    issues.push({
+      where: "edges.source",
+      problem: "endpoint-length-mismatch",
+      detail: `source.length ${source?.length ?? "missing"} !== length ${edgeRows}`
+    });
+  }
+  if (!(target instanceof Uint32Array) || target.length !== edgeRows) {
+    issues.push({
+      where: "edges.target",
+      problem: "endpoint-length-mismatch",
+      detail: `target.length ${target?.length ?? "missing"} !== length ${edgeRows}`
+    });
+  }
+  if (issues.length === 0) {
+    for (let i = 0; i < edgeRows; i++) {
+      if (source[i] >= nodeRows || target[i] >= nodeRows) {
+        issues.push({
+          where: "edges.endpoints",
+          problem: "endpoint-out-of-range",
+          detail: `row ${i}: (${source[i]}, ${target[i]}) with ${nodeRows} nodes`
+        });
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function columnValueAt(col, i) {
+  if (col.nulls !== void 0 && col.nulls[i] !== 0) return null;
+  switch (col.kind) {
+    case "string":
+      return col.dictionary[col.codes[i]];
+    case "bool":
+      return col.data[i] !== 0;
+    default:
+      return col.data[i];
+  }
+}
+function materializeColumnarSnapshot(snapshot) {
+  const nodeCols = Object.entries(snapshot.nodes.columns ?? {});
+  const nodeIds = snapshot.nodes.ids;
+  const nodes = new Array(snapshot.nodes.length);
+  for (let i = 0; i < snapshot.nodes.length; i++) {
+    const attrs = {};
+    for (const [name, col] of nodeCols) attrs[name] = columnValueAt(col, i);
+    nodes[i] = { id: nodeIds.dictionary[nodeIds.codes[i]], attrs };
+  }
+  const edgeCols = Object.entries(snapshot.edges.columns ?? {});
+  const edgeIds = snapshot.edges.ids;
+  const { source, target } = snapshot.edges;
+  const edges = new Array(snapshot.edges.length);
+  for (let i = 0; i < snapshot.edges.length; i++) {
+    const attrs = {};
+    for (const [name, col] of edgeCols) attrs[name] = columnValueAt(col, i);
+    edges[i] = {
+      id: edgeIds.dictionary[edgeIds.codes[i]],
+      source: nodes[source[i]].id,
+      target: nodes[target[i]].id,
+      attrs
+    };
+  }
+  return {
+    datasetKey: snapshot.datasetKey,
+    sourceRevision: snapshot.sourceRevision,
+    nodes,
+    edges
+  };
+}
+function buildAcceptedFromColumnar(snapshot, acceptance) {
+  const nodeCols = Object.entries(snapshot.nodes.columns ?? {});
+  const nodeIds = snapshot.nodes.ids;
+  const nodes = new Array(acceptance.acceptedNodeCount);
+  const nodeIndex = /* @__PURE__ */ new Map();
+  let outN = 0;
+  for (let i = 0; i < snapshot.nodes.length; i++) {
+    if (acceptance.keepNodes[i] !== 1) continue;
+    const attrs = {};
+    for (const [name, col] of nodeCols) attrs[name] = columnValueAt(col, i);
+    const id = nodeIds.dictionary[nodeIds.codes[i]];
+    nodeIndex.set(id, outN);
+    nodes[outN] = { id, attrs };
+    outN += 1;
+  }
+  const edgeCols = Object.entries(snapshot.edges.columns ?? {});
+  const edgeIds = snapshot.edges.ids;
+  const { source, target } = snapshot.edges;
+  const edges = new Array(acceptance.acceptedEdgeCount);
+  let outE = 0;
+  for (let e = 0; e < snapshot.edges.length; e++) {
+    if (acceptance.keepEdges[e] !== 1) continue;
+    const attrs = {};
+    for (const [name, col] of edgeCols) attrs[name] = columnValueAt(col, e);
+    edges[outE] = {
+      id: edgeIds.dictionary[edgeIds.codes[e]],
+      // Endpoint STRINGS resolve through the original row (a dropped
+      // duplicate row shares its survivor's id string by construction).
+      source: nodeIds.dictionary[nodeIds.codes[source[e]]],
+      target: nodeIds.dictionary[nodeIds.codes[target[e]]],
+      attrs
+    };
+    outE += 1;
+  }
+  return {
+    datasetKey: snapshot.datasetKey,
+    sourceRevision: snapshot.sourceRevision,
+    nodes,
+    edges,
+    nodeIndex,
+    diagnostics: acceptance.diagnostics
+  };
+}
+function columnarArrayBuffers(snapshot) {
+  const buffers = /* @__PURE__ */ new Set();
+  const add = (view) => {
+    if (view !== void 0 && view.buffer instanceof ArrayBuffer) buffers.add(view.buffer);
+  };
+  const addColumn = (col) => {
+    if (col.kind === "string") add(col.codes);
+    else add(col.data);
+    add(col.nulls);
+  };
+  addColumn(snapshot.nodes.ids);
+  for (const col of Object.values(snapshot.nodes.columns ?? {})) addColumn(col);
+  addColumn(snapshot.edges.ids);
+  for (const col of Object.values(snapshot.edges.columns ?? {})) addColumn(col);
+  add(snapshot.edges.source);
+  add(snapshot.edges.target);
+  return [...buffers];
+}
+function detachColumnarBuffers(snapshot) {
+  let detached = 0;
+  for (const buffer of columnarArrayBuffers(snapshot)) {
+    if (buffer.byteLength === 0) continue;
+    const transferable = buffer;
+    if (typeof transferable.transfer === "function") {
+      transferable.transfer();
+    } else {
+      structuredClone(buffer, { transfer: [buffer] });
+    }
+    detached += 1;
+  }
+  return detached;
+}
+
+// src/worker/lane.ts
+function defaultWorkerUrl() {
+  return new URL("./worker/entry.js", import.meta.url);
+}
+function transportFromWorker(worker) {
+  return {
+    post: (envelope, transfers) => worker.postMessage(envelope, [...transfers]),
+    onReply: (cb) => {
+      worker.onmessage = (ev) => cb(ev.data);
+    },
+    onError: (cb) => {
+      worker.onerror = (ev) => cb(ev.message !== "" ? ev.message : "worker error");
+      worker.onmessageerror = () => cb("worker messageerror (unclonable reply)");
+    },
+    terminate: () => worker.terminate()
+  };
+}
+var WorkerLane = class {
+  options;
+  sequencer = new EnvelopeSequencer();
+  ledger = new RequestLedger();
+  pending = /* @__PURE__ */ new Map();
+  transport = null;
+  /** null = not yet booted; false = boot failed (permanent for this lane). */
+  availableState = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  available() {
+    return this.availableState;
+  }
+  /** Synchronous boot probe for callers that must pick a lane NOW (the
+   * instance's sync applyHostUpdate cannot await a rejected request). */
+  ensureBooted() {
+    return this.boot();
+  }
+  /** Boot lazily on first use. A throwing factory (no Worker global, CSP,
+   * missing asset) marks the lane unavailable FOREVER — one diagnostic,
+   * then the caller's main path owns every subsequent request. */
+  boot() {
+    if (this.availableState !== null) return this.availableState;
+    try {
+      let transport = this.options.transport ?? null;
+      if (transport === null) {
+        const factory = this.options.factory;
+        const worker = factory !== void 0 && "create" in factory ? factory.create() : new Worker(
+          factory !== void 0 && "url" in factory ? factory.url : defaultWorkerUrl(),
+          { type: "module" }
+        );
+        transport = transportFromWorker(worker);
+      }
+      transport.onReply((reply) => this.settle(reply));
+      transport.onError?.((reason) => this.fail(reason));
+      this.transport = transport;
+      this.availableState = true;
+    } catch (err) {
+      this.availableState = false;
+      this.options.onUnavailable?.(err instanceof Error ? err.message : String(err));
+    }
+    return this.availableState;
+  }
+  /** Async worker death (P1: a constructed-but-dead worker must strand
+   * NOTHING): every pending request rejects as 'worker-failed' so callers
+   * run their main-lane fallback, the lane goes permanently unavailable,
+   * and the unavailability callback fires (the instance one-shots it). */
+  fail(reason) {
+    if (this.availableState === false) return;
+    this.availableState = false;
+    this.options.onUnavailable?.(reason);
+    for (const [id, entry] of this.pending) {
+      this.pending.delete(id);
+      entry.reject(new Error("worker-failed"));
+    }
+    this.ledger.abortAll();
+    this.transport?.terminate();
+    this.transport = null;
+  }
+  settle(reply) {
+    const original = this.ledger.settle(reply);
+    if (reply.inReplyTo === void 0) return;
+    const entry = this.pending.get(reply.inReplyTo);
+    this.pending.delete(reply.inReplyTo);
+    if (entry === void 0) return;
+    if (original === null) {
+      entry.reject(new Error("superseded"));
+      return;
+    }
+    entry.resolve(reply);
+  }
+  /**
+   * Send one request. Resolves with the reply envelope (op 'result' or
+   * 'error' — protocol errors are DATA to the caller, not exceptions);
+   * rejects only on supersession/abort/unavailability.
+   */
+  request(epoch, entity, op, payload, transfers, klass, lane) {
+    if (!this.boot()) {
+      return Promise.reject(new Error("worker-unavailable"));
+    }
+    const envelope = this.sequencer.make(epoch, entity, op, payload);
+    const signal = this.ledger.track(envelope, klass, lane);
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new Error("superseded"));
+        return;
+      }
+      signal.addEventListener(
+        "abort",
+        () => {
+          if (this.pending.delete(envelope.msgId)) reject(new Error("superseded"));
+        },
+        { once: true }
+      );
+      this.pending.set(envelope.msgId, { resolve, reject });
+      this.transport.post(envelope, transfers);
+    });
+  }
+  /** Abort everything in flight (epoch advance / detach / dataset swap).
+   * The ledger's controllers fire each pending promise's abort listener;
+   * the sweep below catches anything tracked before a listener attached —
+   * rejects stay idempotent through the delete guard. */
+  abortAll() {
+    this.ledger.abortAll();
+    for (const [id, entry] of this.pending) {
+      this.pending.delete(id);
+      entry.reject(new Error("aborted"));
+    }
+  }
+  terminate() {
+    this.abortAll();
+    this.transport?.terminate();
+    this.transport = null;
+    this.availableState = null;
+  }
+};
+
 // src/filter.ts
-function resolveFilterField(item, field) {
-  if (field === "id") return item.id;
+function resolveFilterField(item, field2) {
+  if (field2 === "id") return item.id;
   const attrs = item.attrs;
-  return attrs?.[field];
+  return attrs?.[field2];
 }
 function filterValuesEqual(a, b) {
   if (typeof a === "number" && typeof b === "number") {
@@ -2769,7 +3539,7 @@ function compileSelector(selector) {
     };
   }
   let current = null;
-  const resolve = (field) => current === null ? void 0 : resolveFilterField(current, field);
+  const resolve = (field2) => current === null ? void 0 : resolveFilterField(current, field2);
   return {
     errors,
     test(item) {
@@ -3047,6 +3817,16 @@ var MetricStore = class {
   /** Admitted async columns by metric name; NaN encodes null. */
   columns = /* @__PURE__ */ new Map();
   degreePasses = 0;
+  /** §17 telemetry: estimated bytes of metric storage held (S13-T07). */
+  estimatedBytes() {
+    let bytes = 0;
+    for (const col of this.columns.values()) bytes += col.byteLength;
+    const dc = this.degreeCache;
+    if (dc !== null) {
+      bytes += dc.degree.byteLength + dc.inDegree.byteLength + dc.outDegree.byteLength;
+    }
+    return bytes;
+  }
   /** Number of combined degree-family compute passes (test observability). */
   get degreeComputePasses() {
     return this.degreePasses;
@@ -3278,6 +4058,7 @@ function resolveEnginePolicy(capabilities, requested) {
     images: imagesNative ? "native" : "placeholder",
     linkPicking: capabilities.linkPicking ? "native" : "cpu-fallback",
     clusterForce: clusterForceNative ? "native" : "inert",
+    quiescence: capabilities.idleFrames === "stops" ? "stops" : "free-running",
     // Defensive snapshot: the policy must not alias the caller's array.
     rangedChannels: new Set(capabilities.rangeUpdates),
     degradations: Object.freeze(degradations)
@@ -3302,12 +4083,27 @@ function assertCapabilityMethodParity(engine) {
 }
 function normalizeCommitForCapabilities(commit, capabilities) {
   const config = commit.config;
+  const declaredRanged = new Set(capabilities.rangeUpdates);
+  const undeclaredPatches = commit.bufferPatches !== void 0 ? Object.keys(commit.bufferPatches).filter(
+    (ch) => !declaredRanged.has(ch)
+  ) : [];
   const dropResources = capabilities.pointImages !== true && commit.resources !== void 0;
   const dropLinkArrows = capabilities.edgeArrows !== true && config !== void 0 && config.linkArrows !== void 0;
   const dropCluster = capabilities.clusterForce !== true && config !== void 0 && config.cluster !== void 0;
-  if (!dropResources && !dropLinkArrows && !dropCluster) return { commit, dropped: [] };
+  if (!dropResources && !dropLinkArrows && !dropCluster && undeclaredPatches.length === 0) {
+    return { commit, dropped: [] };
+  }
   const dropped = [];
   const next = { ...commit };
+  if (undeclaredPatches.length > 0) {
+    const kept = { ...next.bufferPatches };
+    for (const ch of undeclaredPatches) {
+      delete kept[ch];
+      dropped.push(`bufferPatches.${ch}`);
+    }
+    if (Object.keys(kept).length > 0) next.bufferPatches = kept;
+    else delete next.bufferPatches;
+  }
   if (dropResources) {
     delete next.resources;
     dropped.push("resources");
@@ -3660,7 +4456,7 @@ var Lane = class {
   }
 };
 function newMembership(capacity) {
-  return { flags: new Uint8Array(capacity), list: [] };
+  return { flags: new Uint8Array(capacity), list: [], holes: 0 };
 }
 function growMembership(mem, capacity) {
   if (capacity <= mem.flags.length) return;
@@ -3686,6 +4482,12 @@ var SoftMask = class {
   overflowedFlag = false;
   /** Total memberships currently held across all sources and lanes. */
   totalHeld = 0;
+  /** §17 O(Δ) op counters (F10-02 gate instrumentation). */
+  statsBox = {
+    slotsVisited: 0,
+    zeroCrossings: 0,
+    cascadeEdgesVisited: 0
+  };
   constructor(nodeCapacity, edgeCapacity) {
     checkCapacity(nodeCapacity, "nodeCapacity");
     checkCapacity(edgeCapacity, "edgeCapacity");
@@ -3780,6 +4582,14 @@ var SoftMask = class {
           this.applyMembership(this.edgeDimLane, state.edgeDim, dimIdx);
         }
       },
+      updateNodeFailures: (addHide, removeHide, crossings) => {
+        ensureAlive();
+        this.applyMembershipDelta(this.nodeHideLane, state.nodeHide, addHide, removeHide, crossings);
+      },
+      updateEdgeFailures: (addHide, removeHide) => {
+        ensureAlive();
+        this.applyMembershipDelta(this.edgeHideLane, state.edgeHide, addHide, removeHide);
+      },
       clear: () => {
         ensureAlive();
         this.clearSource(state);
@@ -3833,6 +4643,34 @@ var SoftMask = class {
     this.cascadeSource ??= this.acquire("\xA79.1 node\u2192edge cascade");
     this.cascadeSource.setEdgeFailures(failing);
   }
+  /**
+   * O(incident-edges) delta form of the §9.1 cascade (F10-02): for each node
+   * whose HIDE visibility crossed zero, recompute only its incident edges'
+   * cascade state from the CURRENT node counters and apply the delta through
+   * the same internal cascade source the full form uses — the two compose
+   * freely (the full form re-baselines). Edges shared by two crossed nodes
+   * are visited twice; the membership delta is idempotent, so the second
+   * visit is an O(1) no-op. `incidence` must describe the SAME `links`
+   * buffer (edge slot i ↔ links[2i]/[2i+1]).
+   */
+  applyNodeCascadeToEdgesDelta(links, incidence, crossedNodes) {
+    if (crossedNodes.length === 0) return;
+    const hide = this.nodeHideLane.counters;
+    this.cascadeSource ??= this.acquire("\xA79.1 node\u2192edge cascade");
+    const nowFailing = [];
+    const nowClear = [];
+    for (let k = 0; k < crossedNodes.length; k++) {
+      const edges = incidentEdgesOf(incidence, crossedNodes[k]);
+      for (let j = 0; j < edges.length; j++) {
+        const edge = edges[j];
+        this.statsBox.cascadeEdgesVisited += 1;
+        const failing = hide[links[edge * 2]] !== 0 || hide[links[edge * 2 + 1]] !== 0;
+        if (failing) nowFailing.push(edge);
+        else nowClear.push(edge);
+      }
+    }
+    this.cascadeSource.updateEdgeFailures(nowFailing, nowClear);
+  }
   /**
    * Drains the zero-crossing dirty lists accumulated since the previous
    * drain. Only NET flips are emitted (state compared against the previous
@@ -3848,6 +4686,27 @@ var SoftMask = class {
       edgeVisibleCount: this.edgeHideLane.zeroCount
     };
   }
+  /** §17 telemetry: estimated bytes of mask storage held (S13-T07):
+   * four counter lanes (+pending trackers) and per-source flag columns. */
+  estimatedBytes() {
+    let bytes = 0;
+    for (const lane of [this.nodeHideLane, this.nodeDimLane, this.edgeHideLane, this.edgeDimLane]) {
+      bytes += lane.counters.byteLength + lane.pending.byteLength;
+    }
+    for (const src of this.sources) {
+      bytes += src.nodeHide.flags.byteLength + src.nodeDim.flags.byteLength + src.edgeHide.flags.byteLength + src.edgeDim.flags.byteLength;
+    }
+    return bytes;
+  }
+  /** §17 O(Δ) op counters (live object — snapshot before comparing). */
+  get stats() {
+    return this.statsBox;
+  }
+  resetStats() {
+    this.statsBox.slotsVisited = 0;
+    this.statsBox.zeroCrossings = 0;
+    this.statsBox.cascadeEdgesVisited = 0;
+  }
   visibleNodeCount() {
     return this.nodeHideLane.zeroCount;
   }
@@ -3912,15 +4771,62 @@ var SoftMask = class {
     const prev = mem.list;
     for (let i = 0; i < prev.length; i++) {
       const slot = prev[i];
-      if ((flags[slot] & 2) === 0) {
-        flags[slot] = 0;
-        this.decrement(lane, slot);
-      }
+      const f = flags[slot];
+      if ((f & 2) !== 0) continue;
+      if ((f & 1) !== 0) this.decrement(lane, slot);
+      flags[slot] = 0;
     }
     for (let i = 0; i < next.length; i++) flags[next[i]] = 1;
     mem.list = next;
+    mem.holes = 0;
+  }
+  /**
+   * O(Δ) delta ops on one lane membership (F10-02). Adds and removes are
+   * idempotent per slot (adding a member / removing a non-member is a
+   * no-op); removed slots leave HOLES in `list` (compacted past 50%), so
+   * replace/clear passes must honor the bit0 guard above. `crossings`, when
+   * given, is cleared and then receives this CALL's hide zero-crossings.
+   */
+  applyMembershipDelta(lane, mem, add, remove, crossings) {
+    if (crossings !== void 0) {
+      crossings.becameFailing.length = 0;
+      crossings.becameClear.length = 0;
+    }
+    const capacity = lane.counters.length;
+    const flags = mem.flags;
+    const check = (slot) => {
+      if (!Number.isInteger(slot) || slot < 0 || slot >= capacity) {
+        throw new RangeError(`SoftMask: ${lane.label} slot ${slot} out of range [0, ${capacity})`);
+      }
+    };
+    if (add !== null) for (let i = 0; i < add.length; i++) check(add[i]);
+    if (remove !== null) for (let i = 0; i < remove.length; i++) check(remove[i]);
+    if (add !== null) {
+      for (let i = 0; i < add.length; i++) {
+        const slot = add[i];
+        this.statsBox.slotsVisited += 1;
+        if ((flags[slot] & 1) !== 0) continue;
+        flags[slot] = 1;
+        mem.list.push(slot);
+        this.increment(lane, slot, crossings);
+      }
+    }
+    if (remove !== null) {
+      for (let i = 0; i < remove.length; i++) {
+        const slot = remove[i];
+        this.statsBox.slotsVisited += 1;
+        if ((flags[slot] & 1) === 0) continue;
+        flags[slot] = 0;
+        mem.holes += 1;
+        this.decrement(lane, slot, crossings);
+      }
+    }
+    if (mem.holes > mem.list.length >> 1) {
+      mem.list = mem.list.filter((slot) => (flags[slot] & 1) !== 0);
+      mem.holes = 0;
+    }
   }
-  increment(lane, slot) {
+  increment(lane, slot, crossings) {
     this.totalHeld += 1;
     const before = lane.counters[slot];
     if (before === COUNTER_MAX) {
@@ -3930,16 +4836,20 @@ var SoftMask = class {
     lane.counters[slot] = before + 1;
     if (before === 0) {
       lane.zeroCount -= 1;
+      this.statsBox.zeroCrossings += 1;
+      crossings?.becameFailing.push(slot);
       this.markDirty(lane, slot, true);
     }
   }
-  decrement(lane, slot) {
+  decrement(lane, slot, crossings) {
     this.totalHeld -= 1;
     const before = lane.counters[slot];
     if (before === 0) return;
     lane.counters[slot] = before - 1;
     if (before === 1) {
       lane.zeroCount += 1;
+      this.statsBox.zeroCrossings += 1;
+      crossings?.becameClear.push(slot);
       this.markDirty(lane, slot, false);
     }
   }
@@ -4355,7 +5265,15 @@ function upperBound(values, sorted, target) {
 }
 var TypedColumnCrossfilter = class {
   /** Test instrumentation; see CrossfilterStats. Reset with resetStats(). */
-  stats = { slotsWalked: 0, fullSorts: 0, permutationMerges: 0 };
+  stats = {
+    slotsWalked: 0,
+    fullSorts: 0,
+    permutationMerges: 0,
+    binUpdates: 0,
+    filteredRecomputes: 0
+  };
+  /** Count of dims whose filtered layer is live-maintained (F10-02). */
+  liveDims = 0;
   dims = [];
   byKey = /* @__PURE__ */ new Map();
   specs = [];
@@ -4377,6 +5295,29 @@ var TypedColumnCrossfilter = class {
     this.stats.slotsWalked = 0;
     this.stats.fullSorts = 0;
     this.stats.permutationMerges = 0;
+    this.stats.binUpdates = 0;
+    this.stats.filteredRecomputes = 0;
+  }
+  /** §17 telemetry: estimated bytes of typed-column storage held (S13-T07).
+   * Documented components: per-dim value/permutation/bin/code/pass arrays,
+   * the global failure counter, and the external mask. */
+  estimatedBytes() {
+    let bytes = this.failCount.byteLength + (this.externalMask?.byteLength ?? 0);
+    for (const d of this.dims) {
+      bytes += d.pass.byteLength;
+      if (d.kind === "categorical") {
+        bytes += d.codes.byteLength;
+      } else {
+        bytes += d.values.byteLength + d.sorted.byteLength + d.slotBin.byteLength;
+      }
+    }
+    return bytes;
+  }
+  /** F10-02 live-layer bookkeeping — the ONLY writer of `filteredLive`. */
+  setFilteredLive(dim, live) {
+    if (dim.filteredLive === live) return;
+    dim.filteredLive = live;
+    this.liveDims += live ? 1 : -1;
   }
   /**
    * (Re)initialize columns from scratch. Clears all brushes and the external
@@ -4426,7 +5367,9 @@ var TypedColumnCrossfilter = class {
       this.applyRangeTransition(dim, normalized.brush, delta);
     }
     dim.brush = normalized.brush;
-    for (const other of this.dims) if (other !== dim) other.filteredDirty = true;
+    for (const other of this.dims) {
+      if (other !== dim && !other.filteredLive) other.filteredDirty = true;
+    }
     this.revision++;
     this.notify();
     return delta;
@@ -4452,7 +5395,10 @@ var TypedColumnCrossfilter = class {
       if (unchanged) return;
       this.externalMask = Uint8Array.from(passSlots);
     }
-    for (const d of this.dims) d.filteredDirty = true;
+    for (const d of this.dims) {
+      this.setFilteredLive(d, false);
+      d.filteredDirty = true;
+    }
     this.notify();
   }
   /**
@@ -4466,6 +5412,7 @@ var TypedColumnCrossfilter = class {
     if (dim.filteredDirty) {
       this.recomputeFiltered(dim);
       dim.filteredDirty = false;
+      this.setFilteredLive(dim, true);
     }
     const bins = [];
     const categories = [];
@@ -4530,13 +5477,16 @@ var TypedColumnCrossfilter = class {
       this.externalMask = em;
     }
     this.n = newN;
+    for (const dim of this.dims) {
+      this.setFilteredLive(dim, false);
+      dim.filteredDirty = true;
+    }
     for (const dim of this.dims) {
       const pass = new Uint8Array(newN).fill(1);
       pass.set(dim.pass);
       dim.pass = pass;
       if (dim.kind === "categorical") this.appendCat(dim, newNodes, oldN);
       else this.appendRange(dim, newNodes, oldN);
-      dim.filteredDirty = true;
     }
     for (let s = oldN; s < newN; s++) {
       (this.failCount[s] === 0 ? delta.shown : delta.hidden).push(s);
@@ -4600,6 +5550,7 @@ var TypedColumnCrossfilter = class {
     return dim;
   }
   buildDims(nodes, specs) {
+    this.liveDims = 0;
     const seen = /* @__PURE__ */ new Set();
     const dims = [];
     for (const spec of specs) {
@@ -4655,6 +5606,7 @@ var TypedColumnCrossfilter = class {
       invalidSlots,
       brush: null,
       filteredDirty: true,
+      filteredLive: false,
       filteredBins: []
     };
     this.rebinRange(dim);
@@ -4696,6 +5648,7 @@ var TypedColumnCrossfilter = class {
       invalidSlots,
       brush: null,
       filteredDirty: true,
+      filteredLive: false,
       filteredCats: []
     };
   }
@@ -4744,13 +5697,58 @@ var TypedColumnCrossfilter = class {
       const next = this.failCount[slot] - 1;
       this.failCount[slot] = next;
       if (next === 0) delta.shown.push(slot);
+      if (this.liveDims > 0) this.maintainFiltered(dim, slot, next, 1);
     } else {
       if (dim.pass[slot] === 0) return;
       dim.pass[slot] = 0;
       const prev = this.failCount[slot];
       this.failCount[slot] = prev + 1;
       if (prev === 0) delta.hidden.push(slot);
+      if (this.liveDims > 0) this.maintainFiltered(dim, slot, prev, -1);
+    }
+  }
+  /**
+   * F10-02 inline maintenance of LIVE filtered layers, dispatched from the
+   * one place that knows the failCount transition. `boundary` is the
+   * other-failures picture at the interesting side of the flip (after for
+   * shown, before for hidden):
+   *  - 0 → the slot crossed the FULLY-VISIBLE boundary: every other live
+   *    layer counts it (own layers ignore the own-dim brush, so the brushed
+   *    dim's layer is provably unchanged by its own flip);
+   *  - 1 → exactly one OTHER dim still fails the slot: only that dim's
+   *    what-if-I-cleared-mine layer flips;
+   *  - ≥2 → no layer can change.
+   * External-mask-excluded and hygiene-invalid slots contribute nothing
+   * either way and are skipped.
+   */
+  maintainFiltered(brushed, slot, boundary, sign) {
+    if (boundary > 1) return;
+    const ext = this.externalMask;
+    if (ext !== null && ext[slot] === 0) return;
+    if (boundary === 0) {
+      for (const d of this.dims) {
+        if (d === brushed || !d.filteredLive) continue;
+        this.adjustLayer(d, slot, sign);
+      }
+      return;
+    }
+    for (const d of this.dims) {
+      if (d === brushed || d.pass[slot] !== 0) continue;
+      if (d.filteredLive) this.adjustLayer(d, slot, sign);
+      break;
+    }
+  }
+  adjustLayer(d, slot, sign) {
+    if (d.kind === "categorical") {
+      const c = d.codes[slot];
+      if (c < 0) return;
+      d.filteredCats[c] = (d.filteredCats[c] ?? 0) + sign;
+    } else {
+      const b = d.slotBin[slot];
+      if (b < 0) return;
+      d.filteredBins[b] = (d.filteredBins[b] ?? 0) + sign;
     }
+    this.stats.binUpdates += 1;
   }
   walkSorted(dim, from, to, nowPass, delta) {
     for (let i = from; i < to; i++) this.flip(dim, dim.sorted[i], nowPass, delta);
@@ -4919,6 +5917,7 @@ var TypedColumnCrossfilter = class {
   }
   // --- lazy filtered layer -----------------------------------------------------
   recomputeFiltered(dim) {
+    this.stats.filteredRecomputes += 1;
     const ext = this.externalMask;
     const fc = this.failCount;
     if (dim.kind === "categorical") {
@@ -5250,7 +6249,8 @@ var GRAPH_THEME_DARK = Object.freeze({
   edgeDefault: "rgba(255,255,255,0.15)",
   labelFg: "#e6e9f0",
   accent: "#3b82f6",
-  mutedAlpha: 0.15
+  mutedAlpha: 0.15,
+  emphasisRing: "#7aa2f7"
 });
 var GRAPH_THEME_LIGHT = Object.freeze({
   background: "#ffffff",
@@ -5258,7 +6258,8 @@ var GRAPH_THEME_LIGHT = Object.freeze({
   edgeDefault: "rgba(15,23,42,0.18)",
   labelFg: "#0f172a",
   accent: "#2563eb",
-  mutedAlpha: 0.2
+  mutedAlpha: 0.2,
+  emphasisRing: "#2563eb"
 });
 function resolveTheme(input) {
   const base = input !== void 0 && input.base === "light" ? GRAPH_THEME_LIGHT : GRAPH_THEME_DARK;
@@ -5270,10 +6271,11 @@ function resolveTheme(input) {
   if (input.labelFg !== void 0) out.labelFg = input.labelFg;
   if (input.accent !== void 0) out.accent = input.accent;
   if (input.mutedAlpha !== void 0) out.mutedAlpha = input.mutedAlpha;
+  if (input.emphasisRing !== void 0) out.emphasisRing = input.emphasisRing;
   return out;
 }
 function sameTheme(a, b) {
-  return a.background === b.background && a.nodeDefault === b.nodeDefault && a.edgeDefault === b.edgeDefault && a.labelFg === b.labelFg && a.accent === b.accent && a.mutedAlpha === b.mutedAlpha;
+  return a.background === b.background && a.nodeDefault === b.nodeDefault && a.edgeDefault === b.edgeDefault && a.labelFg === b.labelFg && a.accent === b.accent && a.mutedAlpha === b.mutedAlpha && a.emphasisRing === b.emphasisRing;
 }
 var ZOOM_STEP = 1.5;
 var EMPTY_IDS = [];
@@ -5300,6 +6302,9 @@ var TIMELINE_COALESCE_WINDOW_MS = Number.MAX_SAFE_INTEGER;
 var DEV = Boolean(import.meta.env?.DEV);
 var nowMs = () => Date.now();
 var DEFAULT_RGBA = [0.66, 0.66, 0.66, 1];
+var PERF_SAMPLE_THROTTLE_MS = 1e3;
+var FRAME_PRESSURE_ENGAGE_MS = 40;
+var FRAME_PRESSURE_CLEAR_MS = 28;
 var LABEL_RERANK_THROTTLE_MS = 100;
 var SIM_HOT_REFRESH_MS = 500;
 function sameIds(a, b) {
@@ -5372,6 +6377,7 @@ function createGraphInstance(opts) {
   let overlayIdSeq = 0;
   let edgeIndexById = EMPTY_INDEX2;
   let adjacency = null;
+  let sceneIncidence = null;
   let lastLinkWidths = null;
   let scopeSpec = null;
   const scopeExtraIds = /* @__PURE__ */ new Set();
@@ -5505,6 +6511,8 @@ function createGraphInstance(opts) {
   let theme = resolveTheme(void 0);
   let edgeArrows = false;
   let showLinks = true;
+  let emphasisRingOn = true;
+  let emphasizedNodeId = null;
   let nodeImage;
   let labelsConfig;
   const metricStore = new MetricStore();
@@ -5534,11 +6542,140 @@ function createGraphInstance(opts) {
   const positionSubs = /* @__PURE__ */ new Set();
   let currentPlacements = [];
   let labelPositionCache = null;
+  let frameCadence = 0;
+  let quiescenceAsserted = false;
+  let quiescenceTimer = null;
   let lastHotRefreshMs = null;
   let rerankTimer = null;
   let lastOverloadCount = 0;
   const projectScratch = [0, 0];
   let dataDiags = [];
+  let columnarDiags = [];
+  const executionMode = opts.execution ?? "main";
+  let workerLane = null;
+  let workerDiags = [];
+  let workerUnavailableReported = false;
+  let pendingDeriveToken = 0;
+  function workerEligible() {
+    if (executionMode === "main") return false;
+    if (workerLane === null) {
+      workerLane = new WorkerLane({
+        ...opts.workerFactory !== void 0 ? { factory: opts.workerFactory } : {},
+        onUnavailable: (reason) => {
+          if (workerUnavailableReported) return;
+          workerUnavailableReported = true;
+          workerDiags = [
+            {
+              code: "worker-unavailable",
+              severity: executionMode === "worker" ? "error" : "info",
+              count: 1,
+              sampleIds: [],
+              message: `worker lane unavailable (${reason}) \u2014 columnar acceptance runs on the main lane`
+            }
+          ];
+        }
+      });
+    }
+    return workerLane.ensureBooted();
+  }
+  function scheduleWorkerAcceptance(columnar, deferredMetrics) {
+    const lane = workerLane;
+    pendingDeriveToken += 1;
+    const token = pendingDeriveToken;
+    const payload = {
+      nodeIdTable: encodeStringTable(columnar.nodes.ids.dictionary),
+      nodeIdCodes: columnar.nodes.ids.codes.slice(),
+      nodeCount: columnar.nodes.length,
+      edgeIdTable: encodeStringTable(columnar.edges.ids.dictionary),
+      edgeIdCodes: columnar.edges.ids.codes.slice(),
+      edgeSource: columnar.edges.source.slice(),
+      edgeTarget: columnar.edges.target.slice(),
+      edgeCount: columnar.edges.length
+    };
+    const transfers = collectTransfers([
+      payload.nodeIdTable.offsets,
+      payload.nodeIdTable.bytes,
+      payload.nodeIdCodes,
+      payload.edgeIdTable.offsets,
+      payload.edgeIdTable.bytes,
+      payload.edgeIdCodes,
+      payload.edgeSource,
+      payload.edgeTarget
+    ]);
+    void lane.request(token, "scene", "derive-columnar", payload, transfers, "guaranteed", "derive").then((reply) => {
+      if (destroyed || token !== pendingDeriveToken) return;
+      if (reply.op !== "result") {
+        workerDiags = [
+          {
+            code: "worker-unavailable",
+            severity: "error",
+            count: 1,
+            sampleIds: [],
+            message: `worker derive failed (${String(reply.payload.message)}) \u2014 snapshot dropped`
+          }
+        ];
+        publish({ diagnostics: composeDiagnostics() });
+        return;
+      }
+      const acceptance = reply.payload;
+      acceptanceQueue.admit(() => {
+        if (destroyed || token !== pendingDeriveToken) return;
+        const mutated = acceptance.keepNodes.length !== columnar.nodes.length || acceptance.keepEdges.length !== columnar.edges.length || validateColumnarStructure(columnar).length > 0;
+        if (mutated) {
+          columnarDiags = [
+            {
+              code: "invalid-columnar-snapshot",
+              severity: "error",
+              count: 1,
+              sampleIds: [],
+              message: "columnar snapshot mutated while worker acceptance was pending \u2014 rejected whole (\xA75: source coordinates are immutable; publish a new sourceRevision)"
+            }
+          ];
+          publish({ diagnostics: composeDiagnostics() });
+          return;
+        }
+        const preAccepted = buildAcceptedFromColumnar(columnar, acceptance);
+        applyHostUpdateInner(
+          {
+            data: {
+              datasetKey: columnar.datasetKey,
+              sourceRevision: columnar.sourceRevision,
+              nodes: [],
+              edges: []
+            },
+            ...deferredMetrics !== void 0 ? { metrics: deferredMetrics } : {}
+          },
+          preAccepted
+        );
+        if (columnar.bufferOwnership === "transfer") detachColumnarBuffers(columnar);
+      });
+    }).catch((err) => {
+      if (destroyed || token !== pendingDeriveToken) return;
+      const message = err instanceof Error ? err.message : String(err);
+      if (message !== "worker-unavailable" && message !== "worker-failed") return;
+      acceptanceQueue.admit(() => {
+        if (destroyed || token !== pendingDeriveToken) return;
+        if (validateColumnarStructure(columnar).length > 0) {
+          columnarDiags = [
+            {
+              code: "invalid-columnar-snapshot",
+              severity: "error",
+              count: 1,
+              sampleIds: [],
+              message: "columnar snapshot mutated while worker acceptance was pending \u2014 rejected whole (\xA75: source coordinates are immutable; publish a new sourceRevision)"
+            }
+          ];
+          publish({ diagnostics: composeDiagnostics() });
+          return;
+        }
+        applyHostUpdateInner({
+          data: materializeColumnarSnapshot(columnar),
+          ...deferredMetrics !== void 0 ? { metrics: deferredMetrics } : {}
+        });
+        if (columnar.bufferOwnership === "transfer") detachColumnarBuffers(columnar);
+      });
+    });
+  }
   let nodeColorDiags = [];
   let nodeSizeDiags = [];
   let linkColorDiags = [];
@@ -5602,6 +6739,46 @@ function createGraphInstance(opts) {
     }
     pendingHistoryDepths = null;
     store.setState((prev) => ({ ...prev, ...patch }));
+    if (patch.visible !== void 0 || patch.nodeCount !== void 0) {
+      evaluateLadderCounts();
+    }
+  }
+  function evaluateLadderCounts() {
+    if (destroyed) return;
+    const vis = store.getState().visible;
+    const events = degradeController.evaluateCounts({ nodes: vis.nodes, edges: vis.edges });
+    for (const event of events) applyDegradeEvent(event);
+  }
+  function applyDegradeEvent(event) {
+    if (event.step === "cap-dom-labels") {
+      if (event.engaged && !capLabelsNudged) {
+        capLabelsNudged = true;
+        console.warn(
+          "orbit: cap-dom-labels engaged \u2014 DOM labels are hard-capped at the label budget above limits.domLabelNodes visible nodes (\xA717). A GPU label lane (labelStrategy 'sdf') is the planned scale path (S13-T05, deferred)."
+        );
+      }
+      scheduleViewportRerank();
+    }
+    if (event.step === "batch-histograms" && !event.engaged) {
+      flushCrossfilterNotify();
+    }
+    if (event.step === "defer-images" && !event.engaged && imageRefsDeferred) {
+      pushImageRefs();
+    }
+    if (event.step === "disable-transitions") {
+      const eng = engineIfReady();
+      if (eng !== null) {
+        const revisions = { ...store.getState().revisions };
+        revisions.render += 1;
+        commitToEngine(eng, {
+          revision: revisions.render,
+          config: { transitionDurationMs: event.engaged ? 0 : null }
+        });
+        revisions.appliedRender = eng.appliedRevision();
+        store.setState((prev) => ({ ...prev, revisions }));
+      }
+    }
+    emit("degrade", event);
   }
   function emitInstanceError(detail, phase, cause) {
     engineDiags = [
@@ -6019,6 +7196,9 @@ function createGraphInstance(opts) {
     return k === void 0 ? void 0 : accepted.edges[k];
   }
   function applyEdgeHover(edge, transitionsOnly) {
+    if (edge !== null && degradeController.isEngaged("defer-link-picking") && store.getState().simulationRunning) {
+      return;
+    }
     const edgeId = edge === null ? null : edge.id;
     const hover = store.getState().hover;
     const changed = hover.edgeId !== edgeId;
@@ -6061,6 +7241,8 @@ function createGraphInstance(opts) {
   function composeDiagnostics() {
     return [
       ...dataDiags,
+      ...columnarDiags,
+      ...workerDiags,
       ...ingestMergeDiags,
       ...ingestCommitDiags.map((e) => e.diag),
       ...nodeColorDiags,
@@ -6112,7 +7294,60 @@ function createGraphInstance(opts) {
     baseLinkColors = null;
     basePointColorsSynthesized = false;
     baseLinkColorsSynthesized = false;
-  }
+    nodeAlphaComposer.reset();
+    edgeAlphaComposer.reset();
+    sceneIncidence = null;
+  }
+  const brushCrossings = { becameFailing: [], becameClear: [] };
+  const brushSceneAdd = [];
+  const brushSceneRemove = [];
+  const nodeAlphaComposer = new IncrementalAlphaComposer();
+  const edgeAlphaComposer = new IncrementalAlphaComposer();
+  const PATCH_FULL_UPLOAD_RATIO = 0.5;
+  function buildAlphaPatches(buf, slotLists, stride) {
+    const slots = [];
+    for (const list of slotLists) for (const slot of list) slots.push(slot);
+    slots.sort((a, b) => a - b);
+    const patches = [];
+    let runStart = -1;
+    let runEnd = -1;
+    for (const slot of slots) {
+      if (slot < runEnd) continue;
+      if (slot === runEnd) {
+        runEnd = slot + 1;
+        continue;
+      }
+      if (runStart >= 0) {
+        patches.push({
+          start: runStart * stride,
+          data: buf.subarray(runStart * stride, runEnd * stride)
+        });
+      }
+      runStart = slot;
+      runEnd = slot + 1;
+    }
+    if (runStart >= 0) {
+      patches.push({
+        start: runStart * stride,
+        data: buf.subarray(runStart * stride, runEnd * stride)
+      });
+    }
+    return patches;
+  }
+  const pressureSampler = new PressureSampler();
+  const resolvedLimits = resolveScaleLimits(opts.limits);
+  const degradeController = new DegradeController(resolvedLimits.limits, () => nowMs());
+  let capLabelsNudged = false;
+  let imageRefsDeferred = false;
+  let lastCommitMs;
+  let lastPerfSampleAt = -Infinity;
+  const perfCounters = {
+    brushSlotsTranslated: 0,
+    fullBrushRefreshes: 0,
+    fullCascades: 0,
+    fullNodeRecomposes: 0,
+    fullEdgeRecomposes: 0
+  };
   function evaluateFilterMembership() {
     if (softMask === null || maskFilterSource === null) return;
     const model = sceneModel();
@@ -6190,6 +7425,7 @@ function createGraphInstance(opts) {
   }
   function refreshBrushMembership() {
     if (softMask === null || maskBrushSource === null || scene === null) return;
+    perfCounters.fullBrushRefreshes += 1;
     const slots = [];
     for (const s of crossfilterHiddenBase) {
       const id = crossfilterRowIds[s];
@@ -6199,8 +7435,45 @@ function createGraphInstance(opts) {
     }
     maskBrushSource.setNodeFailures(slots, null);
   }
+  function refreshBrushMembershipDelta(delta) {
+    if (softMask === null || maskBrushSource === null || scene === null) return false;
+    if (groupRewrite !== null) return false;
+    const identity = accepted !== null && sceneModel() === accepted && crossfilterRowsRef === accepted.nodes;
+    const sceneRef = scene;
+    const translate = (baseSlots, out) => {
+      out.length = 0;
+      for (let i = 0; i < baseSlots.length; i++) {
+        const s = baseSlots[i];
+        perfCounters.brushSlotsTranslated += 1;
+        if (identity) {
+          if (s < sceneRef.count) out.push(s);
+          continue;
+        }
+        const id = crossfilterRowIds[s];
+        if (id === void 0) continue;
+        const idx = sceneRef.indexById.get(id);
+        if (idx !== void 0) out.push(idx);
+      }
+    };
+    translate(delta.hidden, brushSceneAdd);
+    translate(delta.shown, brushSceneRemove);
+    maskBrushSource.updateNodeFailures(brushSceneAdd, brushSceneRemove, brushCrossings);
+    return true;
+  }
   function cascadeNodeMask() {
-    if (softMask !== null && scene !== null) softMask.applyNodeCascadeToEdges(scene.links);
+    if (softMask !== null && scene !== null) {
+      perfCounters.fullCascades += 1;
+      softMask.applyNodeCascadeToEdges(scene.links);
+    }
+  }
+  function cascadeNodeMaskDelta() {
+    if (softMask === null || scene === null) return;
+    const failing = brushCrossings.becameFailing;
+    const cleared = brushCrossings.becameClear;
+    if (failing.length === 0 && cleared.length === 0) return;
+    sceneIncidence ??= buildIncidence(scene.links, scene.count);
+    const crossed = failing.length === 0 ? cleared : cleared.length === 0 ? failing : [...failing, ...cleared];
+    softMask.applyNodeCascadeToEdgesDelta(scene.links, sceneIncidence, crossed);
   }
   function refreshGroupMaskMembership(hidden) {
     if (softMask === null || maskGroupSource === null) return;
@@ -6289,6 +7562,8 @@ function createGraphInstance(opts) {
     refreshGroupMaskMembership(hidden);
     cascadeNodeMask();
     softMask.drainDirty();
+    nodeAlphaComposer.reset();
+    edgeAlphaComposer.reset();
     return filterDiags !== before;
   }
   function computeVisibleCounts() {
@@ -6332,6 +7607,7 @@ function createGraphInstance(opts) {
   }
   function composeNodeAlphaBuffer(base) {
     if (softMask === null || scene === null) return base;
+    perfCounters.fullNodeRecomposes += 1;
     const out = new Float32Array(base);
     const n = scene.count;
     const dimAlpha = theme.mutedAlpha;
@@ -6343,6 +7619,7 @@ function createGraphInstance(opts) {
   }
   function composeEdgeAlphaBuffer(base) {
     if (softMask === null && pathDimEdges === null || scene === null) return base;
+    perfCounters.fullEdgeRecomposes += 1;
     const out = new Float32Array(base);
     const n = scene.linkCount;
     const dimAlpha = theme.mutedAlpha;
@@ -6357,6 +7634,36 @@ function createGraphInstance(opts) {
     }
     return out;
   }
+  function composeNodeAlphaIncremental(drain) {
+    const base = basePointColorBuffer();
+    if (softMask === null || scene === null) return base;
+    const mask = softMask;
+    const dimAlpha = theme.mutedAlpha;
+    const alphaOf = (i) => mask.nodeAlpha(i, dimAlpha);
+    const seeded = nodeAlphaComposer.ensureSeeded(base, scene.count, dimAlpha, null, alphaOf);
+    if (seeded) {
+      nodeAlphaComposer.note(drain.nodes);
+      nodeAlphaComposer.note(drain.nodesAlpha);
+    }
+    return nodeAlphaComposer.nextBuffer(base, alphaOf);
+  }
+  function composeEdgeAlphaIncremental(drain) {
+    const base = baseLinkColorBuffer();
+    if (softMask === null || scene === null) return base;
+    if (pathDimEdges !== null) {
+      edgeAlphaComposer.reset();
+      return composeEdgeAlphaBuffer(base);
+    }
+    const mask = softMask;
+    const dimAlpha = theme.mutedAlpha;
+    const alphaOf = (k) => mask.edgeAlpha(k, dimAlpha);
+    const seeded = edgeAlphaComposer.ensureSeeded(base, scene.linkCount, dimAlpha, null, alphaOf);
+    if (seeded) {
+      edgeAlphaComposer.note(drain.edges);
+      edgeAlphaComposer.note(drain.edgesAlpha);
+    }
+    return edgeAlphaComposer.nextBuffer(base, alphaOf);
+  }
   function publishMaskFastPath(extraPatch, diagsChanged) {
     const prev = store.getState();
     const patch = { ...extraPatch };
@@ -6380,13 +7687,48 @@ function createGraphInstance(opts) {
           };
           const buffers = visDirty.nodeColor || visDirty.nodeSize ? { ...projectChannelBuffers(visDirty) ?? {} } : {};
           if (visDirty.nodeColor || visDirty.nodeSize) diagsChanged = true;
+          const maskPhaseT0 = performance.now();
+          const rangedChannels = session !== null && session.policy !== null ? session.policy.rangedChannels : null;
+          const bufferPatches = {};
           if (nodesAffected && buffers.pointColor === void 0) {
-            buffers.pointColor = composeNodeAlphaBuffer(basePointColorBuffer());
+            const reseedsBefore = nodeAlphaComposer.reseeds;
+            const composed = composeNodeAlphaIncremental(drain);
+            const changed = drain.nodes.length + drain.nodesAlpha.length;
+            if (rangedChannels !== null && rangedChannels.has("pointColor") && nodeAlphaComposer.reseeds === reseedsBefore && changed < scene.count * PATCH_FULL_UPLOAD_RATIO) {
+              bufferPatches.pointColor = buildAlphaPatches(
+                composed,
+                [drain.nodes, drain.nodesAlpha],
+                4
+              );
+            } else {
+              buffers.pointColor = composed;
+            }
           }
           if (edgesAffected && buffers.linkColor === void 0) {
-            buffers.linkColor = composeEdgeAlphaBuffer(baseLinkColorBuffer());
+            const reseedsBefore = edgeAlphaComposer.reseeds;
+            const composed = composeEdgeAlphaIncremental(drain);
+            const changed = drain.edges.length + drain.edgesAlpha.length;
+            if (rangedChannels !== null && rangedChannels.has("linkColor") && edgeAlphaComposer.reseeds === reseedsBefore && changed < scene.links.length / 2 * PATCH_FULL_UPLOAD_RATIO) {
+              bufferPatches.linkColor = buildAlphaPatches(
+                composed,
+                [drain.edges, drain.edgesAlpha],
+                4
+              );
+            } else {
+              buffers.linkColor = composed;
+            }
           }
-          commitToEngine(eng, { revision: revisions.render, buffers });
+          const maskUploadT0 = performance.now();
+          const maskCommit = { revision: revisions.render, buffers };
+          if (Object.keys(bufferPatches).length > 0) maskCommit.bufferPatches = bufferPatches;
+          commitToEngine(eng, maskCommit);
+          lastCommitMs = {
+            kind: "mask",
+            validate: 0,
+            derive: 0,
+            project: maskUploadT0 - maskPhaseT0,
+            upload: performance.now() - maskUploadT0
+          };
           revisions.appliedRender = eng.appliedRevision();
         }
         patch.revisions = revisions;
@@ -6414,7 +7756,17 @@ function createGraphInstance(opts) {
     crossfilterHiddenBase.clear();
   }
   const crossfilterFacadeListeners = /* @__PURE__ */ new Set();
+  let crossfilterNotifyPending = false;
   function notifyCrossfilterFacade() {
+    if (degradeController.isEngaged("batch-histograms") && engineIfReady() !== null) {
+      crossfilterNotifyPending = true;
+      return;
+    }
+    for (const cb of crossfilterFacadeListeners) cb();
+  }
+  function flushCrossfilterNotify() {
+    if (!crossfilterNotifyPending) return;
+    crossfilterNotifyPending = false;
     for (const cb of crossfilterFacadeListeners) cb();
   }
   function buildCrossfilterEngine() {
@@ -6540,9 +7892,13 @@ function createGraphInstance(opts) {
     for (const s of delta.shown) crossfilterHiddenBase.delete(s);
     if (membershipChanged && scene !== null) {
       ensureMask();
-      refreshBrushMembership();
-      refreshGroupMaskMembership(store.getState().hiddenNodeIds);
-      cascadeNodeMask();
+      if (refreshBrushMembershipDelta(delta)) {
+        cascadeNodeMaskDelta();
+      } else {
+        refreshBrushMembership();
+        refreshGroupMaskMembership(store.getState().hiddenNodeIds);
+        cascadeNodeMask();
+      }
     }
     publishMaskFastPath(extraPatch, false);
   }
@@ -6781,6 +8137,7 @@ function createGraphInstance(opts) {
       const result = reconcileScene(scopedAccepted ?? accepted);
       labelPositionCache = null;
       adjacency = null;
+      sceneIncidence = null;
       structuralChange = result.structuralChange;
       positionChange = result.positionChange;
     }
@@ -6853,6 +8210,8 @@ function createGraphInstance(opts) {
         revisions.scope += 1;
         revisions.render += 1;
         if (eng !== null) {
+          nodeAlphaComposer.reset();
+          edgeAlphaComposer.reset();
           const buffers = {};
           if (nodesAffected) buffers.pointColor = composeNodeAlphaBuffer(basePointColorBuffer());
           if (edgesAffected) buffers.linkColor = composeEdgeAlphaBuffer(baseLinkColorBuffer());
@@ -7047,9 +8406,10 @@ function createGraphInstance(opts) {
     if (eng !== null && scene !== null && labelModel !== null && cfg !== void 0 && cfg.enabled !== false) {
       const sceneRef = scene;
       const vp = store.getState().viewport ?? eng.getViewport() ?? { zoom: 1 };
+      const hardCap = degradeController.isEngaged("cap-dom-labels") ? LABEL_MAX_VISIBLE_DEFAULT : LABEL_MAX_VISIBLE_CAP;
       const k = Math.max(
         0,
-        Math.min(Math.floor(cfg.maxVisible ?? LABEL_MAX_VISIBLE_DEFAULT), LABEL_MAX_VISIBLE_CAP)
+        Math.min(Math.floor(cfg.maxVisible ?? LABEL_MAX_VISIBLE_DEFAULT), hardCap)
       );
       const clusterCandidates = clusterLabelCandidates(cfg, vp.zoom, k);
       const nodeLabelsSuppressed = cfg.maxZoom !== void 0 && vp.zoom <= cfg.maxZoom;
@@ -7518,7 +8878,8 @@ function createGraphInstance(opts) {
       defaultPointColor: theme.nodeDefault,
       defaultLinkColor: theme.edgeDefault,
       linkArrows: edgeArrows,
-      renderLinks: showLinks
+      renderLinks: showLinks,
+      emphasisRingColor: theme.emphasisRing
     };
     if (simulation !== void 0) c.simulation = simulation;
     if (clusterSpec !== null) {
@@ -7578,6 +8939,11 @@ function createGraphInstance(opts) {
   }
   function pushImageRefs() {
     if (session === null || session.policy === null || session.policy.images !== "native") return;
+    if (degradeController.isEngaged("defer-images")) {
+      imageRefsDeferred = true;
+      return;
+    }
+    imageRefsDeferred = false;
     const model = sceneModel();
     if (model === null) return;
     if (nodeImage === void 0) {
@@ -7691,15 +9057,25 @@ function createGraphInstance(opts) {
     }
     eng.setPinnedIndices(indexSet.size > 0 ? [...indexSet] : null);
   }
+  function applyEmphasis(eng, index) {
+    if (!emphasisRingOn) return;
+    eng.setFocusedIndex(index);
+  }
   function reapplyInteractionState(eng) {
     const { selection, pins, pinnedNodeIds, hover } = store.getState();
     if (selection.nodeIds.length > 0 || selection.groupIds.length > 0) {
       pushSelectionToEngine(eng, selection.nodeIds);
     }
     if (pins.size > 0 || pinnedNodeIds.size > 0) pushPinsToEngine(eng, pins);
+    if (emphasizedNodeId !== null && scene !== null && !scene.indexById.has(emphasizedNodeId)) {
+      emphasizedNodeId = null;
+    }
     if (hover.nodeId !== null && scene !== null) {
       const idx = scene.indexById.get(hover.nodeId);
-      if (idx !== void 0) eng.setFocusedIndex(idx);
+      if (idx !== void 0) applyEmphasis(eng, idx);
+    } else if (emphasizedNodeId !== null && scene !== null) {
+      const idx = scene.indexById.get(emphasizedNodeId);
+      if (idx !== void 0) applyEmphasis(eng, idx);
     }
   }
   function maybeFitView(eng) {
@@ -8441,6 +9817,7 @@ function createGraphInstance(opts) {
     invalidateExpansionRecords();
     edgeIndexById = new Map(p.merged.edges.map((e, k) => [e.id, k]));
     adjacency = null;
+    sceneIncidence = null;
     acceptedAdjacency = null;
     acceptedModelSeq += 1;
     scopedAccepted = computeScopedAccepted();
@@ -8610,9 +9987,15 @@ function createGraphInstance(opts) {
       if (pinsChanged || pinnedChanged || structuralChange && (nextPins.size > 0 || nextPinned.size > 0)) {
         pushPinsToEngine(eng, nextPins);
       }
+      if (structuralChange && emphasizedNodeId !== null && !ingestScene.indexById.has(emphasizedNodeId)) {
+        emphasizedNodeId = null;
+      }
       if (structuralChange && !hoverCleared && prev.hover.nodeId !== null) {
         const idx = ingestScene.indexById.get(prev.hover.nodeId);
-        if (idx !== void 0) eng.setFocusedIndex(idx);
+        if (idx !== void 0) applyEmphasis(eng, idx);
+      } else if (structuralChange && emphasizedNodeId !== null) {
+        const idx = ingestScene.indexById.get(emphasizedNodeId);
+        if (idx !== void 0) applyEmphasis(eng, idx);
       }
       if (commitNeeded) maybeFitView(eng);
     }
@@ -9373,6 +10756,7 @@ function createGraphInstance(opts) {
     const result = reconcileScene(scopedAccepted ?? accepted);
     labelPositionCache = null;
     adjacency = null;
+    sceneIncidence = null;
     hardScopeGen += 1;
     visibleGen += 1;
     const filterDiagsChanged = rebuildMaskMemberships(prev.hiddenNodeIds);
@@ -9728,10 +11112,14 @@ function createGraphInstance(opts) {
       checkRestoreAcknowledgement(update);
     });
   }
-  function applyHostUpdateInner(update) {
+  function applyHostUpdateInner(update, preAccepted) {
+    const phaseT0 = performance.now();
+    let phaseProjectStart = phaseT0;
     const issuedModelSeq = acceptedModelSeq;
     let searchIndexRejected = false;
     let crossfilterRejected = false;
+    let columnarRejected = false;
+    let metricsDeferredToWorker = false;
     const diagnosticsForced = pendingDiagnosticsRefresh;
     pendingDiagnosticsRefresh = false;
     if (update.filter !== void 0 && update.filter !== null) {
@@ -9772,11 +11160,42 @@ function createGraphInstance(opts) {
     let positionChange = false;
     let datasetKeyChanged = false;
     let overlayIdsCleared = false;
-    const data = update.data;
+    let data;
+    if (update.data !== void 0 && isColumnarSnapshot(update.data)) {
+      const columnar = update.data;
+      const isColumnarReplay = baseAccepted !== null && baseAccepted.datasetKey === columnar.datasetKey && baseAccepted.sourceRevision === columnar.sourceRevision;
+      if (isColumnarReplay) {
+        data = void 0;
+      } else {
+        const issues = validateColumnarStructure(columnar);
+        if (issues.length > 0) {
+          columnarDiags = [
+            {
+              code: "invalid-columnar-snapshot",
+              severity: "error",
+              count: issues.length,
+              sampleIds: issues.slice(0, DIAGNOSTIC_SAMPLE_CAP).map((i) => i.where),
+              message: `columnar snapshot rejected whole (\xA75.1): ${issues[0].where} \u2014 ${issues[0].detail}`
+            }
+          ];
+          columnarRejected = true;
+          data = void 0;
+        } else if (workerEligible()) {
+          scheduleWorkerAcceptance(columnar, update.metrics);
+          metricsDeferredToWorker = true;
+          data = void 0;
+        } else {
+          data = materializeColumnarSnapshot(columnar);
+          if (columnar.bufferOwnership === "transfer") detachColumnarBuffers(columnar);
+        }
+      }
+    } else {
+      data = update.data;
+    }
     if (data !== void 0) {
       const isReplay = baseAccepted !== null && baseAccepted.datasetKey === data.datasetKey && baseAccepted.sourceRevision === data.sourceRevision;
       if (!isReplay) {
-        const nextAccepted = validateSnapshot(data);
+        const nextAccepted = preAccepted ?? validateSnapshot(data);
         abortAllSessions(null, "replaced: a declarative snapshot was applied (\xA77.5)");
         overlayIdsCleared = clearOverlayState();
         datasetKeyChanged = baseAccepted !== null && baseAccepted.datasetKey !== data.datasetKey;
@@ -9809,8 +11228,11 @@ function createGraphInstance(opts) {
         baseSource = "declarative";
         edgeIndexById = new Map(nextAccepted.edges.map((e, k) => [e.id, k]));
         adjacency = null;
+        sceneIncidence = null;
         acceptedAdjacency = null;
         dataDiags = nextAccepted.diagnostics;
+        columnarDiags = [];
+        pendingDeriveToken += 1;
         dataChanged = true;
       }
     }
@@ -9953,6 +11375,7 @@ function createGraphInstance(opts) {
       const result = reconcileScene(scopedAccepted ?? accepted);
       labelPositionCache = null;
       adjacency = null;
+      sceneIncidence = null;
       structuralChange = result.structuralChange;
       positionChange = result.positionChange;
     }
@@ -9966,6 +11389,7 @@ function createGraphInstance(opts) {
         const result = reconcileScene(scopedAccepted ?? accepted);
         labelPositionCache = null;
         adjacency = null;
+        sceneIncidence = null;
         structuralChange = structuralChange || result.structuralChange;
         positionChange = positionChange || result.positionChange;
       }
@@ -10003,7 +11427,7 @@ function createGraphInstance(opts) {
     if (clusterDiags !== clusterDiagsBefore) groupsDiagsChanged = true;
     let metricsAdmitted = null;
     let metricsProcessed = false;
-    if (update.metrics !== void 0 && update.metrics.length > 0) {
+    if (!metricsDeferredToWorker && update.metrics !== void 0 && update.metrics.length > 0) {
       metricsProcessed = true;
       if (accepted === null || !ensureMetricModel()) {
         metricDiags = [
@@ -10068,6 +11492,7 @@ function createGraphInstance(opts) {
     let configPatch;
     let themeChanged = false;
     let mutedAlphaChanged = false;
+    let emphasisToggled = false;
     let nodeBaseInvalidated = false;
     let linkBaseInvalidated = false;
     {
@@ -10102,6 +11527,10 @@ function createGraphInstance(opts) {
               linkBaseInvalidated = true;
             }
           }
+          if (nextTheme.emphasisRing !== theme.emphasisRing) {
+            c.emphasisRingColor = nextTheme.emphasisRing;
+            any = true;
+          }
           mutedAlphaChanged = nextTheme.mutedAlpha !== theme.mutedAlpha;
           if (groupRewrite !== null && (nextTheme.accent !== theme.accent || nextTheme.nodeDefault !== theme.nodeDefault)) {
             dirtyNodeColor = true;
@@ -10124,6 +11553,10 @@ function createGraphInstance(opts) {
         c.renderLinks = showLinks;
         any = true;
       }
+      if (update.emphasisRing !== void 0 && update.emphasisRing !== emphasisRingOn) {
+        emphasisRingOn = update.emphasisRing;
+        emphasisToggled = true;
+      }
       if (clusterConfigDirty) {
         c.cluster = clusterConfigPayload();
         any = true;
@@ -10325,6 +11758,8 @@ function createGraphInstance(opts) {
       const edgesAffected = drain.edges.length > 0 || drain.edgesAlpha.length > 0;
       maskAffected = nodesAffected || edgesAffected;
       if (maskAffected) {
+        nodeAlphaComposer.reset();
+        edgeAlphaComposer.reset();
         maskBuffers = {};
         if (nodesAffected) maskBuffers.pointColor = composeNodeAlphaBuffer(basePointColorBuffer());
         if (edgesAffected) maskBuffers.linkColor = composeEdgeAlphaBuffer(baseLinkColorBuffer());
@@ -10344,6 +11779,7 @@ function createGraphInstance(opts) {
         maskBuffers.linkColor = composeEdgeAlphaBuffer(baseLinkColorBuffer());
       }
     }
+    phaseProjectStart = performance.now();
     let buffers = projectChannelBuffers({
       nodeColor: dirtyNodeColor,
       nodeSize: dirtyNodeSize,
@@ -10393,7 +11829,15 @@ function createGraphInstance(opts) {
           simRestarted = true;
         }
       }
+      const phaseUploadStart = performance.now();
       commitToEngine(eng, commit);
+      lastCommitMs = {
+        kind: structure !== void 0 ? scopeChanged && !dataChanged ? "scope" : "model" : buffers !== void 0 ? "mask" : "config",
+        validate: 0,
+        derive: phaseProjectStart - phaseT0,
+        project: phaseUploadStart - phaseProjectStart,
+        upload: performance.now() - phaseUploadStart
+      };
       revisions.appliedRender = eng.appliedRevision();
       const facade = session !== null ? session.edgePicking : null;
       if (facade !== null) {
@@ -10433,7 +11877,7 @@ function createGraphInstance(opts) {
       patch.timeline = { playingKey: null };
       changed = true;
     }
-    if (dataChanged || datasetKeyChanged || buffers !== void 0 || labelRerank.diagsChanged || filterDiagsChanged || metricsProcessed || searchIndexRejected || crossfilterRejected || parallelRejected || groupsDiagsChanged || diagnosticsForced) {
+    if (dataChanged || datasetKeyChanged || buffers !== void 0 || labelRerank.diagsChanged || filterDiagsChanged || metricsProcessed || searchIndexRejected || crossfilterRejected || columnarRejected || parallelRejected || groupsDiagsChanged || diagnosticsForced) {
       patch.diagnostics = composeDiagnostics();
       changed = true;
     }
@@ -10502,9 +11946,26 @@ function createGraphInstance(opts) {
       if (pinsChanged || pinnedChanged || structuralChange && (nextPins.size > 0 || nextPinned.size > 0)) {
         pushPinsToEngine(eng, nextPins);
       }
+      if (structuralChange && emphasizedNodeId !== null && scene !== null && !scene.indexById.has(emphasizedNodeId)) {
+        emphasizedNodeId = null;
+      }
       if (structuralChange && !hoverCleared && prev.hover.nodeId !== null && scene !== null) {
         const idx = scene.indexById.get(prev.hover.nodeId);
-        if (idx !== void 0) eng.setFocusedIndex(idx);
+        if (idx !== void 0) applyEmphasis(eng, idx);
+      } else if (structuralChange && emphasizedNodeId !== null && scene !== null) {
+        const idx = scene.indexById.get(emphasizedNodeId);
+        if (idx !== void 0) applyEmphasis(eng, idx);
+      }
+      if (emphasisToggled) {
+        if (!emphasisRingOn) {
+          eng.setFocusedIndex(null);
+        } else if (!hoverCleared && prev.hover.nodeId !== null && scene !== null) {
+          const idx = scene.indexById.get(prev.hover.nodeId);
+          if (idx !== void 0) applyEmphasis(eng, idx);
+        } else if (emphasizedNodeId !== null && scene !== null) {
+          const idx = scene.indexById.get(emphasizedNodeId);
+          if (idx !== void 0) applyEmphasis(eng, idx);
+        }
       }
       if (commitNeeded) maybeFitView(eng);
     }
@@ -10554,7 +12015,8 @@ function createGraphInstance(opts) {
         const nodeId = node === null ? null : node.id;
         const hover = store.getState().hover;
         if (hover.nodeId !== nodeId) publish({ hover: { nodeId, edgeId: hover.edgeId } });
-        s.engine.setFocusedIndex(node === null ? null : index);
+        emphasizedNodeId = null;
+        applyEmphasis(s.engine, node === null ? null : index);
         emit("nodeHover", { node });
       },
       // §13 native-route edge events (§7.4 mapping). Host onLink* events are
@@ -10575,6 +12037,9 @@ function createGraphInstance(opts) {
         emit("edgeClick", { edge });
       },
       onLinkHover(linkIndex) {
+        if (linkIndex !== null && degradeController.isEngaged("defer-link-picking") && store.getState().simulationRunning) {
+          return;
+        }
         if (!active()) return;
         if (linkIndex !== null && !maskEdgeVisibleAt(linkIndex)) linkIndex = null;
         const edge = linkIndex === null ? null : edgeAtLinkIndex(linkIndex) ?? null;
@@ -10616,6 +12081,32 @@ function createGraphInstance(opts) {
        */
       onFrame(timeMs) {
         if (!active()) return;
+        frameCadence += 1;
+        pressureSampler.noteFrame(timeMs, !store.getState().simulationRunning);
+        flushCrossfilterNotify();
+        if (timeMs - lastPerfSampleAt >= PERF_SAMPLE_THROTTLE_MS) {
+          lastPerfSampleAt = timeMs;
+          const ewma = pressureSampler.snapshot().frameEwmaMs;
+          if (Number.isFinite(ewma)) {
+            const vis = store.getState().visible;
+            const visible = { nodes: vis.nodes, edges: vis.edges };
+            if (ewma > FRAME_PRESSURE_ENGAGE_MS) {
+              for (const step of ["cap-dom-labels", "defer-link-picking"]) {
+                const event = degradeController.engageForPressure(step, "frame-pressure", visible);
+                if (event !== null) applyDegradeEvent(event);
+              }
+            } else if (ewma < FRAME_PRESSURE_CLEAR_MS) {
+              for (const step of ["cap-dom-labels", "defer-link-picking"]) {
+                const event = degradeController.clearPressure(step, visible);
+                if (event !== null) applyDegradeEvent(event);
+              }
+            }
+          }
+          if ((listeners.get("perfSample")?.size ?? 0) > 0) {
+            emit("perfSample", getPerfSnapshot());
+          }
+          pressureSampler.resetCounters();
+        }
         if (store.getState().simulationRunning && labelsEnabled()) {
           if (lastHotRefreshMs === null || timeMs - lastHotRefreshMs >= SIM_HOT_REFRESH_MS || timeMs < lastHotRefreshMs) {
             lastHotRefreshMs = timeMs;
@@ -10662,6 +12153,7 @@ function createGraphInstance(opts) {
           notifyLabelSubs(positionSubs);
         }
         emit("simulationEnd", {});
+        armQuiescenceAssertion();
       },
       onError(error) {
         if (!active()) return;
@@ -10739,11 +12231,13 @@ function createGraphInstance(opts) {
   }
   function buildAndCommitFullReplay(s, restartAlpha) {
     const eng = s.engine;
+    const phaseT0 = performance.now();
     const renderRevision = store.getState().revisions.render;
     const replayModel = renderModel();
     if (replayModel !== null) {
       reconcileScene(replayModel);
       const replayScene = scene;
+      const phaseProjectStart = performance.now();
       const commit = {
         revision: renderRevision,
         structure: {
@@ -10767,7 +12261,15 @@ function createGraphInstance(opts) {
         commit.resources = { ...commit.resources ?? {}, pointImageIndex: syncIndex };
       }
       if (restartAlpha !== null) commit.restart = { alpha: restartAlpha };
+      const phaseUploadStart = performance.now();
       commitToEngine(eng, commit);
+      lastCommitMs = {
+        kind: "model",
+        validate: 0,
+        derive: phaseProjectStart - phaseT0,
+        project: phaseUploadStart - phaseProjectStart,
+        upload: performance.now() - phaseUploadStart
+      };
       if (s.edgePicking !== null) {
         if (restartAlpha !== null) s.edgePicking.disarm();
         else s.edgePicking.arm(replayScene.positions, replayScene.links);
@@ -10804,6 +12306,7 @@ function createGraphInstance(opts) {
     const restartAlpha = layout === "force" ? 1 : null;
     const committed = buildAndCommitFullReplay(s, restartAlpha);
     const restarted = committed && accepted !== null && restartAlpha !== null;
+    if (layout === "fixed") eng.pause();
     publish({
       status: "ready",
       revisions: { ...store.getState().revisions, appliedRender: eng.appliedRevision() },
@@ -10859,6 +12362,11 @@ function createGraphInstance(opts) {
     session = null;
     mountPromise = null;
     cancelRerankTimer();
+    flushCrossfilterNotify();
+    if (quiescenceTimer !== null) {
+      clearTimeout(quiescenceTimer);
+      quiescenceTimer = null;
+    }
     const timelinePatch = resetTimelineForPatch();
     s.edgePicking?.destroy();
     s.edgePicking = null;
@@ -10871,10 +12379,48 @@ function createGraphInstance(opts) {
     });
     rerankAndNotify();
   }
+  function armQuiescenceAssertion() {
+    if (quiescenceAsserted || quiescenceTimer !== null || destroyed) return;
+    const env = globalThis.process?.env?.NODE_ENV;
+    if (env !== "development") return;
+    const g = globalThis;
+    if (typeof g.requestAnimationFrame !== "function") return;
+    const armedRender = store.getState().revisions.render;
+    quiescenceTimer = setTimeout(() => {
+      quiescenceTimer = null;
+      const state = store.getState();
+      if (destroyed || state.simulationRunning || state.revisions.render !== armedRender) {
+        return;
+      }
+      quiescenceAsserted = true;
+      const native = g.requestAnimationFrame;
+      if (typeof native !== "function") return;
+      let registrations = 0;
+      const wrapper = (cb) => {
+        registrations += 1;
+        return native.call(globalThis, cb);
+      };
+      g.requestAnimationFrame = wrapper;
+      setTimeout(() => {
+        if (g.requestAnimationFrame === wrapper) g.requestAnimationFrame = native;
+        if (registrations > 0 && !destroyed) {
+          console.warn(
+            `orbit: ${registrations} requestAnimationFrame registration(s) observed over 500ms while this instance is quiescent (\xA717/S13-T06 one-frame-loop). If no app-owned animation is running, a second frame loop is leaking.`
+          );
+        }
+      }, 500);
+    }, 2e3);
+  }
   function destroy() {
     if (destroyed) return;
     destroyed = true;
+    workerLane?.terminate();
+    workerLane = null;
     stopTimelineTimer();
+    if (quiescenceTimer !== null) {
+      clearTimeout(quiescenceTimer);
+      quiescenceTimer = null;
+    }
     timelinePlayingKey = null;
     imagePipeline?.dispose();
     imagePipeline = null;
@@ -11251,6 +12797,9 @@ function createGraphInstance(opts) {
           } else if (wantsManualGroups && !groupsControlled) {
             commitManualGroups(manualGroups.length > 0 ? manualGroups : null);
           }
+          if (state.layout.kind !== layout) {
+            applyHostUpdateInner({ layout: state.layout.kind });
+          }
           if (state.styling !== void 0 && !needsHost) {
             const patch = {};
             if (state.styling.showLinks !== void 0) patch.showLinks = state.styling.showLinks;
@@ -11513,14 +13062,17 @@ function createGraphInstance(opts) {
   }
   function captureExportPin() {
     if (accepted === null) return null;
-    return { accepted, scene, mask: softMask };
+    let visibleIds = null;
+    if (scene !== null) {
+      const slots = visibleSlotsOf(scene, softMask);
+      const ids = /* @__PURE__ */ new Set();
+      for (const i of slots) ids.add(scene.idByIndex[i]);
+      visibleIds = ids;
+    }
+    return { accepted, scene, visibleIds };
   }
   function pinnedVisibleIds(pin) {
-    if (pin.scene === null) return null;
-    const slots = visibleSlotsOf(pin.scene, pin.mask);
-    const ids = /* @__PURE__ */ new Set();
-    for (const i of slots) ids.add(pin.scene.idByIndex[i]);
-    return ids;
+    return pin.visibleIds;
   }
   function pinnedRowCount(pin, scope) {
     if (scope === "accepted") return pin.accepted.nodes.length + pin.accepted.edges.length;
@@ -11622,7 +13174,7 @@ function createGraphInstance(opts) {
     if (eng === null || scene === null) return EMPTY_IDS;
     const idx = scene.indexById.get(id);
     if (idx === void 0) return EMPTY_IDS;
-    eng.setFocusedIndex(idx);
+    applyEmphasis(eng, idx);
     if (effectiveReducedMotion()) eng.zoomToIndex?.(idx, 0);
     else eng.zoomToIndex?.(idx);
     const neighbors = neighborIdsOf(id);
@@ -11637,6 +13189,67 @@ function createGraphInstance(opts) {
     }
     return neighbors;
   }
+  function emphasizeNode(id) {
+    const eng = engineIfReady();
+    if (eng === null) return;
+    if (id === null) {
+      emphasizedNodeId = null;
+      applyEmphasis(eng, null);
+      return;
+    }
+    if (scene === null) return;
+    const idx = scene.indexById.get(id);
+    if (idx !== void 0) {
+      emphasizedNodeId = id;
+      applyEmphasis(eng, idx);
+    }
+  }
+  function getPerfSnapshot() {
+    const st = store.getState();
+    const p = pressureSampler.snapshot();
+    const snap = {
+      at: Date.now(),
+      nodeCount: st.nodeCount,
+      edgeCount: st.edgeCount,
+      visibleNodeCount: st.visible.nodes,
+      visibleEdgeCount: st.visible.edges,
+      estimatedCpuBytes: estimateCpuBytes(),
+      // The acceptance queue is synchronous (depth is 0 outside a job, and a
+      // reader inside a job observes 1); async ingestion depth arrives with
+      // the worker lane (PR-E).
+      queueDepth: acceptanceQueue.active ? 1 : 0,
+      modelRevision: st.revisions.model,
+      scopeRevision: st.revisions.scope,
+      renderRevision: st.revisions.render,
+      appliedRenderRevision: st.revisions.appliedRender,
+      activeDegradations: degradeController.activeSteps(),
+      // 'worker' iff the lane actually boots — a configured-but-unavailable
+      // lane reports the honest 'main' (plus its worker-unavailable diag).
+      execution: workerLane !== null && workerLane.available() === true ? "worker" : "main",
+      rangeUpdates: session !== null && session.policy !== null ? [...session.policy.rangedChannels] : [],
+      pressure: {
+        frameEwmaMs: p.frameEwmaMs,
+        droppedFrames: p.droppedFrames,
+        idleWakeups: p.idleWakeups
+      }
+    };
+    if (lastCommitMs !== void 0) snap.lastCommitMs = { ...lastCommitMs };
+    if (scene !== null) {
+      snap.estimatedGpuBytes = scene.count * (2 + 4 + 1) * 4 + scene.linkCount * (4 + 1 + 2) * 4;
+    }
+    return snap;
+  }
+  function estimateCpuBytes() {
+    let bytes = 0;
+    if (scene !== null) bytes += scene.positions.byteLength + scene.links.byteLength;
+    if (basePointColors !== null) bytes += basePointColors.byteLength;
+    if (baseLinkColors !== null) bytes += baseLinkColors.byteLength;
+    if (lastLinkWidths !== null) bytes += lastLinkWidths.byteLength;
+    bytes += metricStore.estimatedBytes();
+    if (crossfilterEngine !== null) bytes += crossfilterEngine.estimatedBytes();
+    if (softMask !== null) bytes += softMask.estimatedBytes();
+    return bytes;
+  }
   function cameraZoom(factor) {
     const eng = engineIfReady();
     if (eng === null) return;
@@ -11709,6 +13322,7 @@ function createGraphInstance(opts) {
       else eng.setViewport(v);
     },
     focusNode,
+    emphasizeNode,
     requestNodeContextMenu,
     getViewState,
     setViewState,
@@ -11729,6 +13343,9 @@ function createGraphInstance(opts) {
     pickEdgeAt,
     sampleEdgeHover,
     sampleEdgeClick,
+    getFrameCadence: () => frameCadence,
+    getPerfCounters: () => perfCounters,
+    getPerfSnapshot,
     hideNodes,
     showNodes,
     showAll,
@@ -11933,6 +13550,73 @@ var OverviewController = class {
   }
 };
 
-export { ATLAS_MAX_CONCURRENT_DEFAULT, ATLAS_MAX_ENTRIES_DEFAULT, ATLAS_MAX_RETRIES_DEFAULT, AcceptanceQueue, BASE_PENDING_KEY, BRUSH_HISTORY_COALESCE_MS, CATEGORICAL_PALETTE, DEFAULT_BIN_COUNT, DIM_ALPHA_DEFAULT, DIVERGING_RANGE_DEFAULT, DomainStore, EDGE_PICK_TOLERANCE_PX, EdgePickingFacade, GRAPH_THEME_DARK, GRAPH_THEME_LIGHT, HISTORY_LIMIT_DEFAULT, HistoryKernel, INGEST_MAX_FLUSH_LATENCY_MS_DEFAULT, INGEST_MAX_PENDING_BYTES_DEFAULT, INGEST_OVERFLOW_FACTOR, ImageAtlasPipeline, LABEL_MAX_VISIBLE_CAP, LABEL_MAX_VISIBLE_DEFAULT, LinkPickIndex, META_EDGE_MAX_WIDTH, MetricStore, OVERVIEW_HOT_INTERVAL_MS, OVERVIEW_IDLE_INTERVAL_MS, OVERVIEW_SIZE_DEFAULT, OrbitOperationError, OverviewController, PHYSICAL_DEFAULT_LINK_WIDTH, PHYSICAL_DEFAULT_POINT_SIZE, PendingExpansions, Reconciler, SEARCH_CACHE_LIMIT, SEARCH_LIMIT_DEFAULT, SEARCH_SCAN_CHUNK, SEARCH_SCORE_EXACT_ID, SEARCH_SCORE_ID_PREFIX, SEARCH_SCORE_SUBSTRING, SEARCH_SCORE_TOKEN_START_BONUS, SEQUENTIAL_RANGE_DEFAULT, SUPER_NODE_MAX_SIZE, SVG_MAX_ELEMENTS_DEFAULT, SoftMask, SvgBudgetError, TIMELINE_STEP_DEFAULT, TIMELINE_TICK_MS_DEFAULT, TypedColumnCrossfilter, VIEW_STATE_VERSION, admitServiceResult, assertCapabilityMethodParity, baseFromAccepted, baseFromContribution, buildAcceptedAdjacency, buildAdjacency, canonicalFilterKey, canonicalJson2 as canonicalJson, canonicalScaleKey, cascadeEdges, categoricalIndex, categoricalRows, coerceNumeric, coerceNumericInto, collapseParallelEdges, compileEdgeFilter, compileNodeFilter, computeNumericDomain, createGraphInstance, createLocalExpansionService, createLocalSearchService, createRequestContext, deriveGroupsByKey, divergingColor, escapeXml, estimateBatchBytes, evaluateFilterExpr, graphErrorToError, groupByDerivedId, groupSceneKey, interpolateColor, isFatalGraphError, medianLinkWidthPx, mergeDiagnostics, mergeModel, metaEdgePublicId, metaEdgeSceneKey, metaEdgeWidthFor, neighborsOf, newContribution, newStagingTallies, nextRequestId, normalizeCommitForCapabilities, parseColor, pointSegmentDistanceSquared, projectColors, projectSizes, renderSvg, resolveEnginePolicy, resolveFilterField, resolveManualGroups, resolveScope, resolveTheme, resourceLimitFatal, rewriteGroups, sameDataRef, sameGroupBySpec, sameGroupSpecArrays, sceneGroupsOf, sceneLinkRefAt, scenePointRefAt, selectLabelCandidates, sequentialColor, sequentialSize, serviceCacheKey, sessionCommitDiagnostics, stageBatch, superNodeSizeFor, validateFilterExpr, validateGroupBySpec, validateGroupSpecs, validateSnapshot, validateViewState };
+// src/descriptors.ts
+function field(path) {
+  return path;
+}
+var TRANSFORM_OPS = /* @__PURE__ */ new Set(["identity", "number", "lowercase", "date-to-epoch-ms", "coalesce"]);
+function validateFieldAccessor(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { kind: "not-an-object" };
+  }
+  const candidate = value;
+  if (typeof candidate.field !== "string") return { kind: "field-not-a-string" };
+  if (candidate.transform !== void 0) {
+    const t = candidate.transform;
+    if (t === null || typeof t !== "object" || Array.isArray(t)) {
+      return { kind: "transform-not-an-object" };
+    }
+    const op = t.op;
+    if (typeof op !== "string" || !TRANSFORM_OPS.has(op)) {
+      return { kind: "unknown-transform-op", op: String(op) };
+    }
+    if (op === "coalesce" && !("value" in t)) {
+      return { kind: "coalesce-missing-value" };
+    }
+  }
+  return null;
+}
+function isFieldAccessor(value) {
+  return validateFieldAccessor(value) === null;
+}
+function descriptorKey(accessor) {
+  const t = accessor.transform;
+  if (t === void 0) return `f:${accessor.field}|identity`;
+  if (t.op === "coalesce") return `f:${accessor.field}|coalesce:${JSON.stringify(t.value ?? null)}`;
+  return `f:${accessor.field}|${t.op}`;
+}
+function coerceNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function coerceEpochMs(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+function evaluateFieldAccessor(accessor, id, attrs) {
+  const raw = accessor.field === "id" ? id : attrs?.[accessor.field];
+  const t = accessor.transform;
+  if (t === void 0 || t.op === "identity") return raw;
+  switch (t.op) {
+    case "number":
+      return coerceNumber(raw);
+    case "lowercase":
+      return typeof raw === "string" ? raw.toLowerCase() : null;
+    case "date-to-epoch-ms":
+      return coerceEpochMs(raw);
+    case "coalesce":
+      return raw === null || raw === void 0 ? t.value : raw;
+  }
+}
+
+export { ATLAS_MAX_CONCURRENT_DEFAULT, ATLAS_MAX_ENTRIES_DEFAULT, ATLAS_MAX_RETRIES_DEFAULT, AcceptanceQueue, BASE_PENDING_KEY, BRUSH_HISTORY_COALESCE_MS, CATEGORICAL_PALETTE, DEFAULT_BIN_COUNT, DIM_ALPHA_DEFAULT, DIVERGING_RANGE_DEFAULT, DomainStore, EDGE_PICK_TOLERANCE_PX, EdgePickingFacade, GRAPH_THEME_DARK, GRAPH_THEME_LIGHT, HISTORY_LIMIT_DEFAULT, HistoryKernel, INGEST_MAX_FLUSH_LATENCY_MS_DEFAULT, INGEST_MAX_PENDING_BYTES_DEFAULT, INGEST_OVERFLOW_FACTOR, ImageAtlasPipeline, LABEL_MAX_VISIBLE_CAP, LABEL_MAX_VISIBLE_DEFAULT, LinkPickIndex, META_EDGE_MAX_WIDTH, MetricStore, OVERVIEW_HOT_INTERVAL_MS, OVERVIEW_IDLE_INTERVAL_MS, OVERVIEW_SIZE_DEFAULT, OrbitOperationError, OverviewController, PHYSICAL_DEFAULT_LINK_WIDTH, PHYSICAL_DEFAULT_POINT_SIZE, PendingExpansions, Reconciler, SEARCH_CACHE_LIMIT, SEARCH_LIMIT_DEFAULT, SEARCH_SCAN_CHUNK, SEARCH_SCORE_EXACT_ID, SEARCH_SCORE_ID_PREFIX, SEARCH_SCORE_SUBSTRING, SEARCH_SCORE_TOKEN_START_BONUS, SEQUENTIAL_RANGE_DEFAULT, SUPER_NODE_MAX_SIZE, SVG_MAX_ELEMENTS_DEFAULT, SoftMask, SvgBudgetError, TIMELINE_STEP_DEFAULT, TIMELINE_TICK_MS_DEFAULT, TypedColumnCrossfilter, VIEW_STATE_VERSION, admitServiceResult, assertCapabilityMethodParity, baseFromAccepted, baseFromContribution, buildAcceptedAdjacency, buildAcceptedFromColumnar, buildAdjacency, canonicalFilterKey, canonicalJson2 as canonicalJson, canonicalScaleKey, cascadeEdges, categoricalIndex, categoricalRows, coerceNumeric, coerceNumericInto, collapseParallelEdges, columnarArrayBuffers, compileEdgeFilter, compileNodeFilter, computeNumericDomain, createGraphInstance, createLocalExpansionService, createLocalSearchService, createRequestContext, deriveGroupsByKey, descriptorKey, detachColumnarBuffers, divergingColor, escapeXml, estimateBatchBytes, evaluateFieldAccessor, evaluateFilterExpr, field, graphErrorToError, groupByDerivedId, groupSceneKey, interpolateColor, isColumnarSnapshot, isFatalGraphError, isFieldAccessor, materializeColumnarSnapshot, medianLinkWidthPx, mergeDiagnostics, mergeModel, metaEdgePublicId, metaEdgeSceneKey, metaEdgeWidthFor, neighborsOf, newContribution, newStagingTallies, nextRequestId, normalizeCommitForCapabilities, parseColor, pointSegmentDistanceSquared, projectColors, projectSizes, renderSvg, resolveEnginePolicy, resolveFilterField, resolveManualGroups, resolveScope, resolveTheme, resourceLimitFatal, rewriteGroups, sameDataRef, sameGroupBySpec, sameGroupSpecArrays, sceneGroupsOf, sceneLinkRefAt, scenePointRefAt, selectLabelCandidates, sequentialColor, sequentialSize, serviceCacheKey, sessionCommitDiagnostics, stageBatch, superNodeSizeFor, validateColumnarStructure, validateFieldAccessor, validateFilterExpr, validateGroupBySpec, validateGroupSpecs, validateSnapshot, validateViewState };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map