@modernrelay/orbit-core 0.13.5 → 0.14.0

package/dist/{lane-CHHLuxgq.d.ts → lane-_KPQ1deI.d.ts}

@@ -1,29 +1,29 @@
-import { N as NodeId, d as GraphDiagnostic, e as GraphNode } from './index-CFZMson3.js';
+import { N as NodeId, a as GraphDiagnostic, b as GraphNode } from './index-CPRTWpGA.js';
 
 /**
- * §16.3 stage-4 non-collapsing clusters (S12-T06) — pure derivation, no
+ * stage-4 non-collapsing clusters — pure derivation, no
  * engine, no DOM, no instance.
  *
- * Contract summary (spec §16.3 / §7.6 stage 4, R-16.3-17..21):
+ * Contract summary:
  * - Clusters are a categorical PARTITION of the current PHYSICAL scene, never
- *   a rewrite: `deriveClusters` returns membership only. It synthesizes no
- *   super-nodes and no meta-edges, so node and edge counts are identical
- *   before and after a cluster spec lands (R-16.3-17/19) — clusters coexist
- *   with the stage-3 group rewrite by construction.
+ * a rewrite: `deriveClusters` returns membership only. It synthesizes no
+ * super-nodes and no meta-edges, so node and edge counts are identical
+ * before and after a cluster spec lands — clusters coexist
+ * with the stage-3 group rewrite by construction.
  * - `null` (and any non-string) from `by` means UNCLUSTERED: the slot carries
- *   NaN in {@link ClusterDerivation.slotOrdinals} (the engine contract's
- *   "not in any cluster" value, mirroring the NaN-position convention).
+ * NaN in {@link ClusterDerivation.slotOrdinals} (the engine contract's
+ * "not in any cluster" value, mirroring the NaN-position convention).
  * - Missing force centers generate deterministically from the ORDERED cluster
- *   keys plus the layout seed (R-16.3-20). {@link generateClusterCenters} uses
- *   only IEEE-754 correctly-rounded operations (+ - * / and integer ops) — no
- *   transcendentals — so the same ordered keys and seed produce BIT-IDENTICAL
- *   centers on any conforming engine, and a different seed produces different
- *   ones.
- * - Overlay anchoring must never scan members per frame (R-16.3-21):
- *   {@link clusterCentroids} is the ONLY member-scanning anchor path and runs
- *   at settle (from the single permitted §7.1 readback) or at commit under a
- *   fixed layout. {@link clusterProbe} counts every member visit so tests can
- *   pin "zero per-frame member iterations".
+ * keys plus the layout seed. {@link generateClusterCenters} uses
+ * only IEEE-754 correctly-rounded operations (+ - * / and integer ops) — no
+ * transcendentals — so the same ordered keys and seed produce BIT-IDENTICAL
+ * centers on any conforming engine, and a different seed produces different
+ * ones.
+ * - Overlay anchoring must never scan members per frame:
+ * {@link clusterCentroids} is the ONLY member-scanning anchor path and runs
+ * at settle (from the single permitted readback) or at commit under a
+ * fixed layout. {@link clusterProbe} counts every member visit so tests can
+ * pin "zero per-frame member iterations".
  */
 
 /**
@@ -32,7 +32,7 @@ import { N as NodeId, d as GraphDiagnostic, e as GraphNode } from './index-CFZMs
  * O(members) passes); `derivations` counts stage-4 recomputations. Both are
  * unconditional O(1) increments so the instrumented and production paths are
  * identical code. Tests snapshot, act, and compare: a per-frame overlay tick
- * must add ZERO member visits (R-16.3-21) and a stage-5 soft-mask change must
+ * must add ZERO member visits and a stage-5 soft-mask change must
  * add ZERO derivations.
  */
 declare const clusterProbe: {
@@ -44,15 +44,15 @@ declare function resetClusterProbe(): void;
 /**
  * The layout seed generated cluster centers key on.
  *
- * FINDING (S12-T06 investigation, recorded here because it is a contract
+ * FINDING (investigation, recorded here because it is a contract
  * decision): the core owns NO numeric layout seed in v0.10. The only
- * layout-seeding knob on the §13 config contract is
+ * layout-seeding knob on the config contract is
  * `EngineConfigUpdate.seedRadius` (the ring radius unknown/NaN positions seed
  * onto) and `instance.ts` never sets it — every adapter defaults it itself
- * (`CosmosEngine` → `spaceSize / 4`). Spec §10's `LayoutSpec.seed` (the
+ * (`CosmosEngine` → `spaceSize / 4`). `LayoutSpec.seed` (the
  * `static` layout's reproducibility seed) is not implemented in v0.10 either.
  * So this constant is the single named place the instance keys generated
- * centers on until §10's normalized layout object lands and can supply
+ * centers on until normalized layout object lands and can supply
  * `LayoutSpec.seed` here.
  */
 declare const DEFAULT_LAYOUT_SEED = 1592594996;
@@ -64,7 +64,7 @@ declare const DEFAULT_LAYOUT_SEED = 1592594996;
  */
 declare const DEFAULT_CLUSTER_CENTER_RADIUS = 1024;
 /**
- * Deterministic force centers for ORDERED cluster keys (R-16.3-20): a
+ * Deterministic force centers for ORDERED cluster keys: a
  * low-discrepancy (Halton base 2/3) spread offset per key by a seeded hash,
  * mapped into `[-radius, radius]²`.
  *
@@ -77,13 +77,13 @@ declare const DEFAULT_CLUSTER_CENTER_RADIUS = 1024;
 declare function generateClusterCenters(keys: readonly string[], seed?: number, radius?: number): Float32Array;
 /**
  * Force centers for ordered keys with caller-supplied entries winning:
- * ONLY the missing keys generate (R-16.3-20). A non-finite explicit pair is
+ * ONLY the missing keys generate. A non-finite explicit pair is
  * treated as missing (D4 boundary hygiene — a NaN center would poison the
  * engine's force field).
  */
 declare function resolveClusterCenters(keys: readonly string[], explicit: ReadonlyMap<string, readonly [number, number]> | undefined, seed?: number, radius?: number): Float32Array;
 interface ClusterDerivation {
-    /** Distinct keys in FIRST-ENCOUNTER order over the physical scene (the §11
+    /** Distinct keys in FIRST-ENCOUNTER order over the physical scene (the
      * categorical-domain convention, shared with groupBy). Ordinal i ↔ keys[i]. */
     keys: readonly string[];
     /** key → ordinal (the reverse of `keys`). */
@@ -92,7 +92,7 @@ interface ClusterDerivation {
     membersByKey: ReadonlyMap<string, readonly NodeId[]>;
     /**
      * PHYSICAL slot → cluster ordinal, NaN = unclustered. Length is the caller's
-     * `sceneCount`, so synthetic suffix slots (§16.3 super-nodes/meta-edges) are
+     * `sceneCount`, so synthetic suffix slots are
      * always NaN: aggregates are never members of a cluster. This IS the engine
      * `config.cluster.pointClusters` payload — no copy at the sink.
      */
@@ -102,18 +102,18 @@ interface ClusterDerivation {
     diagnostic: GraphDiagnostic | null;
 }
 /**
- * §16.3 stage-4 derivation over the PHYSICAL prefix of the current scene.
+ * stage-4 derivation over the PHYSICAL prefix of the current scene.
  *
  * `nodes` are the physical rows (post-group-rewrite when a rewrite is live)
  * aligned to scene slots `0..nodes.length-1`; `sceneCount` is the FULL scene
  * point count so the returned `slotOrdinals` covers the synthetic suffix too.
- * Preserves everything and synthesizes nothing (R-16.3-17/19).
+ * Preserves everything and synthesizes nothing.
  */
 declare function deriveClusters<N>(nodes: readonly GraphNode<N>[], by: (node: GraphNode<N>) => string | null, sceneCount?: number): ClusterDerivation;
 /**
  * Centroids of every cluster from a slot-aligned position buffer — the ONLY
- * member-scanning anchor path (R-16.3-21). Called at settle (over the single
- * permitted §7.1 readback) and at commit under a FIXED layout; never per
+ * member-scanning anchor path. Called at settle (over the single
+ * permitted readback) and at commit under a FIXED layout; never per
  * frame. Slots with unknown (NaN) positions are skipped; a cluster with no
  * placeable member keeps its `fallback` entry (its force center), so a label
  * never jumps to the origin.
@@ -121,7 +121,7 @@ declare function deriveClusters<N>(nodes: readonly GraphNode<N>[], by: (node: Gr
 declare function clusterCentroids(slotOrdinals: Float32Array, positions: Float32Array, clusterCount: number, fallback: Float32Array): Float32Array;
 
 /**
- * ADR-006 D3 — the worker-lane wire contract: envelope codec, epoch guards,
+ * Worker-lane wire protocol: envelope codec, epoch guards,
  * consolidated transfer lists, and request-class bookkeeping
  * (guaranteed-vs-throttled). Pure functions and one small class; no Worker
  * construction here — the runtime that OWNS a thread imports this, and the
@@ -130,17 +130,17 @@ declare function clusterCentroids(slotOrdinals: Float32Array, positions: Float32
  *
  * Contract invariants (each pinned by test):
  * - `msgId` is monotonic PER DIRECTION; a reply names the request it answers
- *   via `inReplyTo`.
+ * via `inReplyTo`.
  * - Every envelope carries the model acceptance `epoch` it derived from
- *   (I1 discipline: references do not cross threads — epochs replace them).
- *   Results for a superseded epoch are dropped AT THE BOUNDARY, before the
- *   acceptance queue ever sees them.
+ * (I1 discipline: references do not cross threads — epochs replace them).
+ * Results for a superseded epoch are dropped AT THE BOUNDARY, before the
+ * acceptance queue ever sees them.
  * - Transfers are CONSOLIDATED: one ArrayBuffer per channel per message,
- *   deduplicated (two views over one buffer transfer once).
+ * deduplicated (two views over one buffer transfer once).
  * - Request classes: 'guaranteed' requests all complete (structural
- *   derivation); 'throttled' requests coalesce LATEST-WINS per lane key
- *   (styling reprojection) — superseding a pending throttled request aborts
- *   the old one.
+ * derivation); 'throttled' requests coalesce LATEST-WINS per lane key
+ * (styling reprojection) — superseding a pending throttled request aborts
+ * the old one.
  */
 type WorkerEntity = 'nodes' | 'edges' | 'scene';
 interface WorkerEnvelope {
@@ -186,7 +186,7 @@ declare function encodeStringTable(strings: readonly string[]): EncodedStringTab
 declare function decodeStringTable(table: EncodedStringTable): string[];
 
 /**
- * ADR-006 D5 — the main-side worker lane: transport ownership, the request
+ * Main-side worker lane: transport ownership, the request
  * ledger (guaranteed/throttled), and the tri-option factory with the
  * fall-back-to-main contract (`worker-unavailable`, never a crash).
  *
@@ -213,4 +213,4 @@ type WorkerFactoryOption = {
     create: () => Worker;
 } | undefined;
 
-export { type ClusterDerivation as C, DEFAULT_CLUSTER_CENTER_RADIUS as D, type EncodedStringTable as E, type RequestClass as R, type WorkerTransport as W, type WorkerEnvelope as a, type WorkerFactoryOption as b, clusterProbe as c, DEFAULT_LAYOUT_SEED as d, type WorkerEntity as e, clusterCentroids as f, collectTransfers as g, decodeStringTable as h, deriveClusters as i, encodeStringTable as j, generateClusterCenters as k, judgeEpoch as l, resolveClusterCenters as m, resetClusterProbe as r };
+export { type ClusterDerivation as C, DEFAULT_CLUSTER_CENTER_RADIUS as D, type EncodedStringTable as E, type RequestClass as R, type WorkerFactoryOption as W, DEFAULT_LAYOUT_SEED as a, type WorkerEntity as b, type WorkerEnvelope as c, type WorkerTransport as d, clusterCentroids as e, collectTransfers as f, decodeStringTable as g, deriveClusters as h, encodeStringTable as i, generateClusterCenters as j, judgeEpoch as k, clusterProbe as l, resetClusterProbe as m, resolveClusterCenters as r };

package/dist/testing.d.ts

@@ -1,9 +1,9 @@
-import { G as GraphEngine, E as EngineCapabilities, a as EngineCommit, b as EngineHostEvents, F as FitViewOptions, V as ViewportState, c as EngineDiagnostic } from './index-CFZMson3.js';
-import { W as WorkerTransport, a as WorkerEnvelope } from './lane-CHHLuxgq.js';
-export { c as clusterProbe, r as resetClusterProbe } from './lane-CHHLuxgq.js';
+import { a5 as GraphEngine, a7 as EngineCapabilities, a6 as EngineCommit, aJ as EngineHostEvents, aK as FitViewOptions, V as ViewportState, aL as EngineDiagnostic } from './index-CPRTWpGA.js';
+import { d as WorkerTransport, c as WorkerEnvelope } from './lane-_KPQ1deI.js';
+export { l as clusterProbe, m as resetClusterProbe } from './lane-_KPQ1deI.js';
 
 /**
- * FakeEngine — the public headless test seam (§18 /testing, §19).
+ * FakeEngine — the public headless test seam.
  *
  * Implements the full GraphEngine adapter contract with zero DOM/WebGL access
  * so consumer suites can run under node/jsdom. Every public method call is
@@ -23,17 +23,17 @@ interface FakeEngineOptions {
     /** Overrides merged over the defaults (linkPicking/trackedPositions false, rangeUpdates [], simulation true). */
     capabilities?: Partial<EngineCapabilities>;
     /**
-     * When true, commits queue instead of applying immediately; `stepFrame()`
+     * When true, commits queue instead of applying immediately; `stepFrame`
      * applies the oldest queued commit. Lets tests observe the lag between the
-     * desired-render revision and `appliedRevision()`.
+     * desired-render revision and `appliedRevision`.
      */
     manualFrames?: boolean;
     /**
-     * When set, `mount()` records the call, does NOT store the host events, and
+     * When set, `mount` records the call, does NOT store the host events, and
      * rejects with this error — simulates an engine that cannot initialize.
      */
     mountError?: Error;
-    /** Resolved by `captureScreenshot()`; default null (unsupported/not ready). */
+    /** Resolved by `captureScreenshot`; default null (unsupported/not ready). */
     screenshot?: Blob | null;
 }
 /** One recorded public method invocation. */
@@ -45,7 +45,7 @@ declare class FakeEngine implements GraphEngine {
     readonly capabilities: EngineCapabilities;
     /** Every public method call, in order. */
     readonly calls: RecordedCall[];
-    /** Every commit passed to `commit()`, in call order (queued or applied). */
+    /** Every commit passed to `commit`, in call order (queued or applied). */
     readonly commits: EngineCommit[];
     /** The fitView/zoom/setViewport/zoomToIndex entries of `calls`, in order. */
     readonly cameraCalls: RecordedCall[];
@@ -53,32 +53,32 @@ declare class FakeEngine implements GraphEngine {
     private readonly mountError;
     private readonly screenshot;
     private events;
-    /** Auto-advancing activity clock for emitFrame()/stepFrame() (ms). */
+    /** Auto-advancing activity clock for emitFrame/stepFrame (ms). */
     private frameClock;
     private destroyedFlag;
     private viewport;
     private applied;
     private positions;
     /** Links of the most recent structure-bearing commit (commit-time, even in
-     * manualFrames mode) — the adjacency source for neighborIndices(). */
+     * manualFrames mode) — the adjacency source for neighborIndices. */
     private lastLinks;
     private pinned;
     private selected;
-    /** Commits awaiting stepFrame() in manualFrames mode (oldest first). */
+    /** Commits awaiting stepFrame in manualFrames mode (oldest first). */
     private readonly pendingFrames;
     constructor(options?: FakeEngineOptions);
     /** Most recent commit, if any. */
     get lastCommit(): EngineCommit | undefined;
     get destroyed(): boolean;
-    /** Last setPinnedIndices() value (null = unpinned / never pinned). */
+    /** Last setPinnedIndices value (null = unpinned / never pinned). */
     get pinnedIndices(): readonly number[] | null;
-    /** Last setSelectedIndices() value (null = cleared / never selected) — the
-     * §9.1 highlight mirror of {@link pinnedIndices}. */
+    /** Last setSelectedIndices value (null = cleared / never selected) — the
+     * highlight mirror of {@link pinnedIndices}. */
     get selectedIndices(): readonly number[] | null;
     /**
      * Structure of the most recent structure-bearing commit — the geometry the
-     * engine currently holds. Buffer channels commit independently of structure
-     * (§9.1 mask fast path), so the newest commit often carries none.
+     * engine currently holds. Buffer channels commit independently of structure,
+     * so the newest commit often carries none.
      */
     get lastStructure(): NonNullable<EngineCommit['structure']> | undefined;
     /**
@@ -122,9 +122,9 @@ declare class FakeEngine implements GraphEngine {
     destroy(): void;
     /**
      * manualFrames mode: apply the oldest queued commit, making its revision
-     * visible via appliedRevision(). No-op on the queue when empty. A drawn
+     * visible via appliedRevision. No-op on the queue when empty. A drawn
      * frame is also an activity-clock sample, so a mounted engine gets an
-     * `onFrame` tick (§13 overlay/activity clock).
+     * `onFrame` tick.
      */
     stepFrame(): void;
     /**
@@ -162,7 +162,7 @@ declare class FakeEngine implements GraphEngine {
 }
 
 /**
- * §17/S13-T06 requestAnimationFrame audit — the quiescence instrument.
+ * requestAnimationFrame audit — the quiescence instrument.
  *
  * Wraps a window's `requestAnimationFrame` and counts SCHEDULING calls
  * (registrations) separately from delivered ticks: the stop-at-rest claim is
@@ -171,7 +171,7 @@ declare class FakeEngine implements GraphEngine {
  * still re-arming itself.
  *
  * Used three ways: core/react quiescence tests (install, drive the instance,
- * assert `registrations() === 0` over a settled window), the demo e2e's
+ * assert `registrations === 0` over a settled window), the demo e2e's
  * page-side counterpart (same shape, injected via addInitScript), and the
  * dev-mode runtime assertion in the instance. The M0 spike's instrument.ts
  * pioneered the wrapper; this is its reusable, uninstallable form.
@@ -197,7 +197,7 @@ interface RafAudit {
 declare function installRafAudit(win?: Window): RafAudit;
 
 /**
- * In-process worker transport double (ADR-006 D2/D5) — drives the REAL
+ * In-process worker transport double — drives the REAL
  * runtime module through the REAL codec, asynchronously (microtask), with
  * REAL transfer semantics: payloads round through `structuredClone` with
  * the declared transfer list, so a wrong transfer set detaches something

package/dist/testing.js

@@ -1,6 +1,5 @@
-export { clusterProbe, resetClusterProbe } from './chunk-XAR262L3.js';
-import { handleWorkerRequest } from './chunk-GUXIITKK.js';
-import { EnvelopeSequencer } from './chunk-NIJX5NVJ.js';
+import { EnvelopeSequencer, isWellFormedEnvelope, decodeStringTable, acceptColumnar, collectTransfers } from './chunk-KRCG2JFN.js';
+export { clusterProbe, resetClusterProbe } from './chunk-KRCG2JFN.js';
 
 // src/testing/FakeEngine.ts
 var DEFAULT_CAPABILITIES = {
@@ -8,8 +7,8 @@ var DEFAULT_CAPABILITIES = {
   rangeUpdates: [],
   trackedPositions: false,
   simulation: true,
-  // §17: the FakeEngine schedules nothing on its own — frames exist only
-  // when a test calls stepFrame()/emitFrame() — so it is quiescent by
+  // the FakeEngine schedules nothing on its own — frames exist only
+  // when a test calls stepFrame/emitFrame — so it is quiescent by
   // construction, and those calls apply-then-emit, which is genuinely
   // post-draw.
   idleFrames: "stops",
@@ -38,7 +37,7 @@ var FakeEngine = class {
   capabilities;
   /** Every public method call, in order. */
   calls = [];
-  /** Every commit passed to `commit()`, in call order (queued or applied). */
+  /** Every commit passed to `commit`, in call order (queued or applied). */
   commits = [];
   /** The fitView/zoom/setViewport/zoomToIndex entries of `calls`, in order. */
   cameraCalls = [];
@@ -46,18 +45,18 @@ var FakeEngine = class {
   mountError;
   screenshot;
   events = null;
-  /** Auto-advancing activity clock for emitFrame()/stepFrame() (ms). */
+  /** Auto-advancing activity clock for emitFrame/stepFrame (ms). */
   frameClock = 0;
   destroyedFlag = false;
   viewport = { x: 0, y: 0, zoom: 1 };
   applied = null;
   positions = null;
   /** Links of the most recent structure-bearing commit (commit-time, even in
-   * manualFrames mode) — the adjacency source for neighborIndices(). */
+   * manualFrames mode) — the adjacency source for neighborIndices. */
   lastLinks = null;
   pinned = null;
   selected = null;
-  /** Commits awaiting stepFrame() in manualFrames mode (oldest first). */
+  /** Commits awaiting stepFrame in manualFrames mode (oldest first). */
   pendingFrames = [];
   constructor(options = {}) {
     this.capabilities = { ...DEFAULT_CAPABILITIES, ...options.capabilities };
@@ -72,19 +71,19 @@ var FakeEngine = class {
   get destroyed() {
     return this.destroyedFlag;
   }
-  /** Last setPinnedIndices() value (null = unpinned / never pinned). */
+  /** Last setPinnedIndices value (null = unpinned / never pinned). */
   get pinnedIndices() {
     return this.pinned;
   }
-  /** Last setSelectedIndices() value (null = cleared / never selected) — the
-   * §9.1 highlight mirror of {@link pinnedIndices}. */
+  /** Last setSelectedIndices value (null = cleared / never selected) — the
+   * highlight mirror of {@link pinnedIndices}. */
   get selectedIndices() {
     return this.selected;
   }
   /**
    * Structure of the most recent structure-bearing commit — the geometry the
-   * engine currently holds. Buffer channels commit independently of structure
-   * (§9.1 mask fast path), so the newest commit often carries none.
+   * engine currently holds. Buffer channels commit independently of structure,
+   * so the newest commit often carries none.
    */
   get lastStructure() {
     for (let i = this.commits.length - 1; i >= 0; i--) {
@@ -278,9 +277,9 @@ var FakeEngine = class {
   // --- test helpers (not part of GraphEngine) ---
   /**
    * manualFrames mode: apply the oldest queued commit, making its revision
-   * visible via appliedRevision(). No-op on the queue when empty. A drawn
+   * visible via appliedRevision. No-op on the queue when empty. A drawn
    * frame is also an activity-clock sample, so a mounted engine gets an
-   * `onFrame` tick (§13 overlay/activity clock).
+   * `onFrame` tick.
    */
   stepFrame() {
     this.record("stepFrame", []);
@@ -458,6 +457,90 @@ function installRafAudit(win = globalThis) {
   };
 }
 
+// src/worker/runtime.ts
+function handleWorkerRequest(request, sequencer) {
+  if (!isWellFormedEnvelope(request)) {
+    const reply2 = sequencer.make(0, "scene", "error", {
+      message: "malformed envelope (protocol violation)"
+    });
+    return { reply: reply2, transfers: [] };
+  }
+  if (request.op === "derive-columnar") {
+    try {
+      const p = request.payload;
+      const snapshot = {
+        kind: "columnar",
+        datasetKey: "worker",
+        // acceptance rules never read the coordinate
+        sourceRevision: 0,
+        nodes: {
+          ids: {
+            kind: "string",
+            dictionary: decodeStringTable(p.nodeIdTable),
+            codes: p.nodeIdCodes
+          },
+          columns: {},
+          length: p.nodeCount
+        },
+        edges: {
+          ids: {
+            kind: "string",
+            dictionary: decodeStringTable(p.edgeIdTable),
+            codes: p.edgeIdCodes
+          },
+          source: p.edgeSource,
+          target: p.edgeTarget,
+          columns: {},
+          length: p.edgeCount
+        }
+      };
+      const acceptance = acceptColumnar(snapshot);
+      const result = {
+        keepNodes: acceptance.keepNodes,
+        keepEdges: acceptance.keepEdges,
+        acceptedNodeCount: acceptance.acceptedNodeCount,
+        acceptedEdgeCount: acceptance.acceptedEdgeCount,
+        nodeAcceptedIndex: acceptance.nodeAcceptedIndex,
+        links: acceptance.links,
+        diagnostics: acceptance.diagnostics
+      };
+      const reply2 = sequencer.make(
+        request.epoch,
+        request.entity,
+        "result",
+        result,
+        request.msgId
+      );
+      return {
+        reply: reply2,
+        transfers: collectTransfers([
+          result.keepNodes,
+          result.keepEdges,
+          result.nodeAcceptedIndex,
+          result.links
+        ])
+      };
+    } catch (err) {
+      const reply2 = sequencer.make(
+        request.epoch,
+        request.entity,
+        "error",
+        { message: err instanceof Error ? err.message : String(err) },
+        request.msgId
+      );
+      return { reply: reply2, transfers: [] };
+    }
+  }
+  const reply = sequencer.make(
+    request.epoch,
+    request.entity,
+    "error",
+    { message: `unknown op '${request.op}'` },
+    request.msgId
+  );
+  return { reply, transfers: [] };
+}
+
 // src/testing/workerDouble.ts
 function createWorkerDouble() {
   const sequencer = new EnvelopeSequencer();