@kuralle-syrinx/core 4.0.0 → 4.2.0

package/src/interaction-coordinator.ts

@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: MIT
+
+import type { VadAudioPacket } from "./packets.js";
+import type { SttInterimPacket, SttResultPacket } from "./packets.js";
+import { Route } from "./pipeline-bus.js";
+import type { PipelineBus } from "./pipeline-bus.js";
+import { confidenceToWaitMs } from "./confidence-to-wait.js";
+import type { InteractionDecision, InteractionObservation, InteractionPolicy } from "./interaction-policy.js";
+import type { TurnArbiter } from "./turn-arbiter.js";
+import { RuleBasedInteractionPolicy } from "./policies/rule-based.js";
+import { TimerScheduler, type Scheduler } from "./scheduler.js";
+import * as make from "./packet-factories.js";
+
+export interface InteractionCaps {
+  readonly emitsBackchannel?: boolean;
+}
+
+interface PendingTakeTurn {
+  confidence: number;
+  waitMs?: number;
+  transcripts: SttResultPacket[];
+  latestInterim: string;
+  finalizeRequested: boolean;
+}
+
+export class InteractionCoordinator {
+  private readonly disposers: Array<() => void> = [];
+  private readonly pendingTakeTurns = new Map<string, PendingTakeTurn>();
+  private readonly transcriptsByContext = new Map<string, SttResultPacket[]>();
+  private readonly interimByContext = new Map<string, string>();
+  private readonly scheduler: Scheduler;
+
+  constructor(
+    private readonly deps: {
+      bus: PipelineBus;
+      policy: InteractionPolicy;
+      executor: TurnArbiter;
+      caps: InteractionCaps;
+      scheduler?: Scheduler;
+      isUserSpeaking?: () => boolean;
+      isTtsActive?: () => boolean;
+      hasCueAsset?: (cueId: string) => boolean;
+      onBackchannelEmitted?: (contextId: string) => void;
+    },
+  ) {
+    this.scheduler = deps.scheduler ?? new TimerScheduler();
+  }
+
+  initialize(): void {
+    const { bus } = this.deps;
+    this.disposers.push(
+      bus.on("stt.result", (pkt) => {
+        this.handleSttResult(pkt as SttResultPacket);
+      }),
+      bus.on("stt.interim", (pkt) => {
+        this.handleSttInterim(pkt as SttInterimPacket);
+      }),
+      bus.on("vad.speech_started", (pkt) => {
+        this.revokePendingTakeTurn((pkt as { contextId: string }).contextId);
+      }),
+    );
+  }
+
+  dispose(): void {
+    for (const contextId of this.pendingTakeTurns.keys()) {
+      this.revokePendingTakeTurn(contextId);
+    }
+    for (const dispose of this.disposers.splice(0)) {
+      dispose();
+    }
+    this.transcriptsByContext.clear();
+    this.interimByContext.clear();
+  }
+
+  observe(obs: InteractionObservation): void {
+    for (const d of this.deps.policy.observe(obs)) {
+      this.apply(d, obs);
+    }
+  }
+
+  observeBargeInAudio(pkt: VadAudioPacket): boolean {
+    this.observe({
+      kind: "vad_barge_in_audio",
+      contextId: pkt.contextId,
+      timestampMs: pkt.timestampMs,
+      audio: pkt.audio,
+    });
+    if (this.deps.policy instanceof RuleBasedInteractionPolicy) {
+      return this.deps.policy.takeBargeInAudioConsumed();
+    }
+    return this.deps.executor.observeBargeInAudio(pkt);
+  }
+
+  private apply(d: InteractionDecision, obs: InteractionObservation): void {
+    switch (d.kind) {
+      case "take_turn":
+        this.armTakeTurn(obs.contextId, d.confidence, d.waitMs, obs.timestampMs);
+        break;
+      case "hold":
+      case "keep_listening":
+        this.revokePendingTakeTurn(obs.contextId);
+        break;
+      case "interrupt":
+        this.deps.executor.emitInterruptDetected(d.interruptedContextId);
+        break;
+      case "backchannel":
+        this.applyBackchannel(d, obs);
+        break;
+      default:
+        break;
+    }
+  }
+
+  private armTakeTurn(contextId: string, confidence: number, waitMs: number | undefined, timestampMs: number): void {
+    const existing = this.pendingTakeTurns.get(contextId);
+    const pending: PendingTakeTurn = existing ?? {
+      confidence,
+      transcripts: [...(this.transcriptsByContext.get(contextId) ?? [])],
+      latestInterim: this.interimByContext.get(contextId) ?? "",
+      finalizeRequested: false,
+    };
+    pending.confidence = confidence;
+    pending.waitMs = waitMs;
+    this.pendingTakeTurns.set(contextId, pending);
+
+    if (!pending.finalizeRequested) {
+      pending.finalizeRequested = true;
+      this.deps.bus.push(Route.Critical, make.finalizeStt(contextId, timestampMs));
+    }
+    this.tryScheduleTurnComplete(contextId);
+  }
+
+  private handleSttInterim(pkt: SttInterimPacket): void {
+    const text = pkt.text.trim();
+    if (!text) return;
+    this.interimByContext.set(pkt.contextId, text);
+    const pending = this.pendingTakeTurns.get(pkt.contextId);
+    if (pending) pending.latestInterim = text;
+  }
+
+  private handleSttResult(pkt: SttResultPacket): void {
+    const text = pkt.text.trim();
+    if (!text) return;
+    const transcripts = this.transcriptsByContext.get(pkt.contextId) ?? [];
+    if (transcripts.at(-1)?.text.trim() !== text) {
+      transcripts.push(pkt);
+      this.transcriptsByContext.set(pkt.contextId, transcripts);
+    }
+    this.interimByContext.delete(pkt.contextId);
+
+    const pending = this.pendingTakeTurns.get(pkt.contextId);
+    if (!pending) return;
+    pending.transcripts = [...transcripts];
+    pending.latestInterim = "";
+    this.tryScheduleTurnComplete(pkt.contextId);
+  }
+
+  private tryScheduleTurnComplete(contextId: string): void {
+    const pending = this.pendingTakeTurns.get(contextId);
+    if (!pending) return;
+
+    // Anchor the finalize timer at the policy's commitment even before any text
+    // exists — the callback reads live transcript/interim state at fire time and
+    // is the sole gate on whether the turn actually completes.
+    const delayMs = pending.waitMs ?? confidenceToWaitMs(pending.confidence);
+    const timerKey = takeTurnTimerKey(contextId);
+    this.scheduler.cancel(timerKey);
+    this.scheduler.schedule(timerKey, delayMs, () => {
+      const live = this.pendingTakeTurns.get(contextId);
+      if (!live) return;
+
+      const finalText = joinTranscript(live.transcripts, live.latestInterim);
+      // The policy committed to this turn. Prefer real STT finals; if none ever
+      // arrived, fall back to the latest interim so a committed turn is never
+      // silently dropped. Only bail when there is genuinely nothing to commit.
+      if (!finalText) return;
+
+      this.pendingTakeTurns.delete(contextId);
+      const transcripts: SttResultPacket[] =
+        live.transcripts.length > 0
+          ? live.transcripts
+          : [{ kind: "stt.result", contextId, timestampMs: Date.now(), text: finalText, confidence: 0 }];
+      this.deps.bus.push(Route.Main, make.eosTurnComplete(contextId, Date.now(), finalText, transcripts));
+    });
+  }
+
+  private revokePendingTakeTurn(contextId: string): void {
+    if (!this.pendingTakeTurns.has(contextId)) return;
+    this.scheduler.cancel(takeTurnTimerKey(contextId));
+    this.pendingTakeTurns.delete(contextId);
+  }
+
+  private applyBackchannel(
+    d: Extract<InteractionDecision, { kind: "backchannel" }>,
+    obs: InteractionObservation,
+  ): void {
+    const contextId = obs.contextId;
+    this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.candidate", d.cue));
+
+    if (this.deps.caps.emitsBackchannel) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_caps", d.cue));
+      return;
+    }
+    if (this.deps.isTtsActive?.()) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_tts_active", d.cue));
+      return;
+    }
+    if (this.deps.isUserSpeaking?.()) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_user_speaking", d.cue));
+      return;
+    }
+    if (this.deps.hasCueAsset && !this.deps.hasCueAsset(d.cue)) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_missing_asset", d.cue));
+      return;
+    }
+
+    this.deps.bus.push(Route.Main, make.interactionBackchannel(contextId, Date.now(), d.cue));
+    this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.emitted", d.cue));
+    this.deps.onBackchannelEmitted?.(contextId);
+  }
+
+  reset(contextId: string): void {
+    this.revokePendingTakeTurn(contextId);
+    this.transcriptsByContext.delete(contextId);
+    this.interimByContext.delete(contextId);
+    this.deps.policy.reset(contextId);
+  }
+}
+
+function takeTurnTimerKey(contextId: string): string {
+  return `interaction.take_turn:${contextId}`;
+}
+
+function joinTranscript(transcripts: readonly SttResultPacket[], interim: string): string {
+  const segments = [
+    ...transcripts.map((t) => t.text.trim()),
+    ...(interim ? [interim.trim()] : []),
+  ].filter(Boolean);
+  return segments.join(" ").replace(/\s+/g, " ").trim();
+}

package/src/interaction-policy.ts

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT
+
+export interface WordTiming {
+  readonly word: string;
+  readonly startMs: number;
+  readonly endMs: number;
+  readonly confidence: number;
+}
+
+export type InteractionObservation =
+  | {
+      readonly kind: "vad_speech_started";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly confidence: number;
+      readonly interruptedContextId?: string;
+    }
+  | {
+      readonly kind: "vad_speech_activity";
+      readonly contextId: string;
+      readonly timestampMs: number;
+    }
+  | {
+      readonly kind: "vad_speech_ended";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly hasActiveTts: boolean;
+    }
+  | {
+      readonly kind: "vad_barge_in_audio";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly audio: Uint8Array;
+    }
+  | {
+      readonly kind: "stt_partial";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly text: string;
+      readonly confidence?: number;
+      readonly interruptedContextId?: string;
+      readonly wordTimings?: readonly WordTiming[];
+    }
+  | {
+      readonly kind: "stt_final";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly text: string;
+      readonly confidence?: number;
+      readonly interruptedContextId?: string;
+      readonly wordTimings?: readonly WordTiming[];
+    }
+  | {
+      readonly kind: "audio_frame";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly audio?: Int16Array;
+      readonly sampleRateHz?: number;
+      readonly wordTimings?: readonly WordTiming[];
+      readonly prosody?: Float32Array;
+    }
+  | {
+      readonly kind: "playout_tick";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly playedOutMs?: number;
+      readonly ttsActive?: boolean;
+      /** PCM queued for assistant playout. Present on audio-bearing ticks. */
+      readonly audio?: Int16Array;
+      readonly sampleRateHz?: number;
+    }
+  | {
+      readonly kind: "delegate_state";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly delegateInFlight?: boolean;
+      readonly toolCallPhase?: "started" | "delayed" | "complete" | "failed";
+    };
+
+export type InteractionDecision =
+  | { readonly kind: "keep_listening" }
+  | { readonly kind: "take_turn"; readonly confidence: number; readonly waitMs?: number }
+  /** `cue` is a stable pre-cached asset id (e.g. `mm_hmm`), not free-form text. */
+  | { readonly kind: "backchannel"; readonly cue: string }
+  | { readonly kind: "hold" }
+  | { readonly kind: "interrupt"; readonly interruptedContextId: string };
+
+export interface InteractionPolicy {
+  observe(obs: InteractionObservation): readonly InteractionDecision[];
+  reset(contextId: string): void;
+}
+
+/** Optional lifecycle for externally supplied model policies (session-owned). */
+export interface LifecycleInteractionPolicy extends InteractionPolicy {
+  initialize(config: Record<string, unknown>): Promise<void>;
+  close(): Promise<void>;
+}
+
+export function isLifecycleInteractionPolicy(
+  policy: InteractionPolicy,
+): policy is LifecycleInteractionPolicy {
+  const candidate = policy as LifecycleInteractionPolicy;
+  return typeof candidate.initialize === "function" && typeof candidate.close === "function";
+}

package/src/iu-ledger.test.ts

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it, vi } from "vitest";
+import type { IncrementalUnit, IncrementalUnitId } from "./incremental-unit.js";
+import { InMemoryIuLedger, type IuLedgerAnomaly } from "./iu-ledger.js";
+
+function makeId(contextId: string, iuId: string, epoch = 1): IncrementalUnitId {
+  return { contextId, iuId, epoch };
+}
+
+function makeIu(
+  contextId: string,
+  iuId: string,
+  kind: IncrementalUnit["kind"],
+  epoch = 1,
+): IncrementalUnit {
+  return {
+    id: makeId(contextId, iuId, epoch),
+    kind,
+    state: "hypothesized",
+  };
+}
+
+function seedContexts(ledger: InMemoryIuLedger, count: number): IncrementalUnitId {
+  const target = makeId("ctx-target", "iu-target");
+  for (let i = 0; i < count; i++) {
+    ledger.add(makeIu(`ctx-${i}`, `iu-${i}`, "user_turn", i));
+  }
+  ledger.add(makeIu(target.contextId, target.iuId, "user_turn", target.epoch));
+  return target;
+}
+
+describe("InMemoryIuLedger", () => {
+  describe("add", () => {
+    it("registers a hypothesized IU (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      expect(ledger.get(iu.id)?.state).toBe("hypothesized");
+    });
+
+    it("overwrites an existing iuId with the latest add (failure path: stale hypothesis replaced)", () => {
+      const ledger = new InMemoryIuLedger();
+      const first = makeIu("ctx-a", "iu-1", "user_turn", 1);
+      const second = makeIu("ctx-a", "iu-1", "assistant_response", 2);
+      ledger.add(first);
+      ledger.add(second);
+      expect(ledger.get(first.id)?.kind).toBe("assistant_response");
+      expect(ledger.get(first.id)?.id.epoch).toBe(2);
+    });
+  });
+
+  describe("commit", () => {
+    it("transitions hypothesized → committed (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const iu = makeIu("ctx-a", "iu-1", "assistant_response");
+      ledger.add(iu);
+      ledger.commit(iu.id);
+      expect(ledger.get(iu.id)?.state).toBe("committed");
+    });
+
+    it("records committedPrefix when provided (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const iu = makeIu("ctx-a", "iu-1", "tts_segment");
+      ledger.add(iu);
+      ledger.commit(iu.id, { ms: 800, chars: 40 });
+      expect(ledger.get(iu.id)?.committedPrefix).toEqual({ ms: 800, chars: 40 });
+    });
+
+    it("is a no-op on an already-committed IU and fires terminal_op (failure path)", () => {
+      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
+      const ledger = new InMemoryIuLedger(onEvent);
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      ledger.commit(iu.id);
+      ledger.commit(iu.id);
+      expect(ledger.get(iu.id)?.state).toBe("committed");
+      expect(onEvent).toHaveBeenCalledOnce();
+      expect(onEvent).toHaveBeenCalledWith({
+        kind: "terminal_op",
+        op: "commit",
+        id: iu.id,
+        state: "committed",
+      });
+    });
+
+    it("does not un-commit: revoke after commit is a no-op with terminal_op (failure path)", () => {
+      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
+      const ledger = new InMemoryIuLedger(onEvent);
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      ledger.commit(iu.id);
+      ledger.revoke(iu.id);
+      expect(ledger.get(iu.id)?.state).toBe("committed");
+      expect(onEvent).toHaveBeenCalledOnce();
+      expect(onEvent).toHaveBeenCalledWith({
+        kind: "terminal_op",
+        op: "revoke",
+        id: iu.id,
+        state: "committed",
+      });
+    });
+
+    it("fail-open on unknown iuId: no throw, unknown_iu anomaly (failure path)", () => {
+      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
+      const ledger = new InMemoryIuLedger(onEvent);
+      const id = makeId("missing", "iu-1");
+      expect(() => ledger.commit(id)).not.toThrow();
+      expect(onEvent).toHaveBeenCalledWith({ kind: "unknown_iu", op: "commit", id });
+    });
+  });
+
+  describe("revoke", () => {
+    it("transitions hypothesized → revoked (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      ledger.revoke(iu.id);
+      expect(ledger.get(iu.id)?.state).toBe("revoked");
+    });
+
+    it("is a no-op on an already-revoked IU and fires terminal_op (failure path)", () => {
+      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
+      const ledger = new InMemoryIuLedger(onEvent);
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      ledger.revoke(iu.id);
+      ledger.revoke(iu.id);
+      expect(ledger.get(iu.id)?.state).toBe("revoked");
+      expect(onEvent).toHaveBeenCalledOnce();
+      expect(onEvent).toHaveBeenCalledWith({
+        kind: "terminal_op",
+        op: "revoke",
+        id: iu.id,
+        state: "revoked",
+      });
+    });
+
+    it("fail-open on unknown iuId: no throw, unknown_iu anomaly (failure path)", () => {
+      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
+      const ledger = new InMemoryIuLedger(onEvent);
+      const id = makeId("missing", "iu-1");
+      expect(() => ledger.revoke(id)).not.toThrow();
+      expect(onEvent).toHaveBeenCalledWith({ kind: "unknown_iu", op: "revoke", id });
+    });
+  });
+
+  describe("get", () => {
+    it("returns the registered IU (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const iu = makeIu("ctx-a", "iu-1", "user_turn");
+      ledger.add(iu);
+      expect(ledger.get(iu.id)).toBe(iu);
+    });
+
+    it("returns undefined for an unknown id without throwing (failure path)", () => {
+      const ledger = new InMemoryIuLedger();
+      expect(ledger.get(makeId("missing", "iu-1"))).toBeUndefined();
+    });
+  });
+
+  describe("latest", () => {
+    it("returns the most recently added IU of the requested kind (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      ledger.add(makeIu("ctx-a", "iu-1", "user_turn"));
+      ledger.add(makeIu("ctx-a", "iu-2", "assistant_response"));
+      ledger.add(makeIu("ctx-a", "iu-3", "user_turn"));
+      const latest = ledger.latest("ctx-a", "user_turn");
+      expect(latest?.id.iuId).toBe("iu-3");
+    });
+
+    it("returns undefined when no IU of that kind exists (failure path)", () => {
+      const ledger = new InMemoryIuLedger();
+      ledger.add(makeIu("ctx-a", "iu-1", "user_turn"));
+      expect(ledger.latest("ctx-a", "tts_segment")).toBeUndefined();
+      expect(ledger.latest("missing", "user_turn")).toBeUndefined();
+    });
+  });
+
+  describe("clear", () => {
+    it("removes only the requested context (happy path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const a = makeIu("ctx-a", "iu-1", "user_turn");
+      const b = makeIu("ctx-b", "iu-1", "user_turn");
+      ledger.add(a);
+      ledger.add(b);
+      ledger.clear("ctx-a");
+      expect(ledger.get(a.id)).toBeUndefined();
+      expect(ledger.get(b.id)?.state).toBe("hypothesized");
+    });
+
+    it("is a no-op for an unknown context without affecting others (failure path)", () => {
+      const ledger = new InMemoryIuLedger();
+      const b = makeIu("ctx-b", "iu-1", "user_turn");
+      ledger.add(b);
+      ledger.clear("ctx-missing");
+      expect(ledger.get(b.id)?.state).toBe("hypothesized");
+    });
+  });
+
+  describe("monotonic state machine", () => {
+    it("follows hypothesized → committed and hypothesized → revoked only", () => {
+      const ledger = new InMemoryIuLedger();
+      const committed = makeIu("ctx-a", "iu-commit", "user_turn");
+      const revoked = makeIu("ctx-a", "iu-revoke", "user_turn");
+      ledger.add(committed);
+      ledger.add(revoked);
+      ledger.commit(committed.id);
+      ledger.revoke(revoked.id);
+      expect(ledger.get(committed.id)?.state).toBe("committed");
+      expect(ledger.get(revoked.id)?.state).toBe("revoked");
+    });
+  });
+
+  describe("maxContexts bound", () => {
+    it("evicts the oldest context when a new context exceeds the cap (FIFO)", () => {
+      const ledger = new InMemoryIuLedger(() => {}, 3);
+      const a = makeIu("a", "iu-1", "user_turn");
+      const b = makeIu("b", "iu-1", "user_turn");
+      const c = makeIu("c", "iu-1", "user_turn");
+      const d = makeIu("d", "iu-1", "user_turn");
+      ledger.add(a);
+      ledger.add(b);
+      ledger.add(c);
+      ledger.add(d);
+      expect(ledger.get(a.id)).toBeUndefined();
+      expect(ledger.get(b.id)?.state).toBe("hypothesized");
+      expect(ledger.get(c.id)?.state).toBe("hypothesized");
+      expect(ledger.get(d.id)?.state).toBe("hypothesized");
+    });
+
+    it("does not evict when adding another IU to an existing context", () => {
+      const ledger = new InMemoryIuLedger(() => {}, 3);
+      const a1 = makeIu("a", "iu-1", "user_turn");
+      const a2 = makeIu("a", "iu-2", "assistant_response");
+      const b = makeIu("b", "iu-1", "user_turn");
+      const c = makeIu("c", "iu-1", "user_turn");
+      ledger.add(a1);
+      ledger.add(b);
+      ledger.add(c);
+      ledger.add(a2);
+      expect(ledger.get(a1.id)?.state).toBe("hypothesized");
+      expect(ledger.get(a2.id)?.state).toBe("hypothesized");
+      expect(ledger.get(b.id)?.state).toBe("hypothesized");
+      expect(ledger.get(c.id)?.state).toBe("hypothesized");
+    });
+  });
+
+  describe("O(1) per-op (structural)", () => {
+    it("commit/get touch only the target ctx bucket regardless of total ctx count", () => {
+      // Map.get/set/delete are O(1); each hot-path op does at most one outer + one inner lookup.
+      const ledgerSmall = new InMemoryIuLedger();
+      const ledgerLarge = new InMemoryIuLedger();
+      const targetSmall = seedContexts(ledgerSmall, 10);
+      const targetLarge = seedContexts(ledgerLarge, 1000);
+
+      ledgerSmall.commit(targetSmall);
+      ledgerLarge.commit(targetLarge);
+
+      expect(ledgerSmall.get(targetSmall)?.state).toBe("committed");
+      expect(ledgerLarge.get(targetLarge)?.state).toBe("committed");
+
+      const timeOp = (ledger: InMemoryIuLedger, id: IncrementalUnitId) => {
+        const start = performance.now();
+        for (let i = 0; i < 5000; i++) {
+          ledger.get(id);
+        }
+        return performance.now() - start;
+      };
+
+      const tSmall = timeOp(ledgerSmall, targetSmall);
+      const tLarge = timeOp(ledgerLarge, targetLarge);
+      expect(tLarge).toBeLessThan(Math.max(tSmall * 20, 1));
+    });
+  });
+});