@semiont/core 0.5.9 → 0.5.11

package/dist/testing.js

@@ -0,0 +1,745 @@
+import * as fc2 from 'fast-check';
+import { Subject, BehaviorSubject } from 'rxjs';
+
+// src/state-unit-axioms.ts
+function disposeProbe() {
+  let n = 0;
+  return {
+    dispose() {
+      n += 1;
+    },
+    get disposeCount() {
+      return n;
+    }
+  };
+}
+function normalize(r) {
+  if (r && typeof r === "object" && "unit" in r) {
+    return { unit: r.unit, passedIn: r.passedIn ?? [], teardown: r.teardown ?? (() => {
+    }) };
+  }
+  return { unit: r, passedIn: [], teardown: () => {
+  } };
+}
+function swallowAsync(value) {
+  if (value && typeof value === "object" && typeof value.then === "function") {
+    value.then(void 0, () => {
+    });
+  }
+}
+function assertStateUnitAxioms(spec) {
+  const numRuns = spec.numRuns ?? 30;
+  const fresh = () => normalize(spec.setup());
+  const run = (axiom, prop) => {
+    try {
+      fc2.assert(prop, { numRuns });
+    } catch (e) {
+      throw new Error(`${axiom}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  {
+    const { unit, teardown } = fresh();
+    const proto = Object.getPrototypeOf(unit);
+    if (proto !== Object.prototype && proto !== null) {
+      throw new Error("A1: state unit is not a plain object (has a class prototype)");
+    }
+    unit.dispose();
+    teardown();
+  }
+  {
+    const { unit, teardown } = fresh();
+    for (const [key, value] of Object.entries(unit)) {
+      if (value instanceof Subject && value.source === void 0) {
+        throw new Error(`X1: public field "${key}" is a raw Subject \u2014 expose it via .asObservable()`);
+      }
+    }
+    unit.dispose();
+    teardown();
+  }
+  {
+    const { unit, passedIn, teardown } = fresh();
+    unit.dispose();
+    passedIn.forEach((probe, i) => {
+      if (probe.disposeCount > 0) {
+        throw new Error(`A7-passed: the unit disposed injected dependency #${i} (it doesn't own it)`);
+      }
+    });
+    teardown();
+  }
+  run("A5", fc2.property(fc2.integer({ min: 1, max: 20 }), (n) => {
+    const { unit, passedIn, teardown } = fresh();
+    for (let i = 0; i < n; i++) unit.dispose();
+    passedIn.forEach((probe, i) => {
+      if (probe.disposeCount > 0) {
+        throw new Error(`injected dependency #${i} disposed under ${n} dispose() calls`);
+      }
+    });
+    teardown();
+  }));
+  if (spec.surfaces) {
+    const surfaces = spec.surfaces;
+    run("A6", fc2.property(fc2.integer({ min: 1, max: 10 }), (k) => {
+      const { unit, teardown } = fresh();
+      const completed = [];
+      const subs = surfaces(unit).flatMap(
+        (o) => Array.from({ length: k }, () => {
+          const idx = completed.push(false) - 1;
+          return o.subscribe({ complete: () => {
+            completed[idx] = true;
+          } });
+        })
+      );
+      unit.dispose();
+      completed.forEach((seen, idx) => {
+        if (!seen) throw new Error(`a subscriber did not see complete on dispose (k=${k}, sub #${idx})`);
+      });
+      subs.forEach((s) => s.unsubscribe());
+      teardown();
+    }));
+  }
+  if (spec.invocations) {
+    const invocations = spec.invocations;
+    run("A5b", fc2.property(fc2.array(fc2.nat(), { maxLength: 12 }), (seq) => {
+      const { unit, teardown } = fresh();
+      const callers = invocations(unit);
+      unit.dispose();
+      for (const raw of seq) {
+        if (callers.length === 0) break;
+        swallowAsync(callers[raw % callers.length]());
+      }
+      teardown();
+    }));
+  }
+  if (spec.surfaces && spec.invocations) {
+    const surfaces = spec.surfaces;
+    const invocations = spec.invocations;
+    run("X3-runtime", fc2.property(fc2.array(fc2.nat(), { minLength: 1, maxLength: 8 }), (seq) => {
+      const a = fresh();
+      const b = fresh();
+      const bSurfaces = surfaces(b.unit);
+      const bCounts = bSurfaces.map(() => 0);
+      const bSubs = bSurfaces.map((o, i) => o.subscribe(() => {
+        bCounts[i] += 1;
+      }));
+      const baseline = bCounts.slice();
+      const aCallers = invocations(a.unit);
+      for (const raw of seq) {
+        if (aCallers.length === 0) break;
+        swallowAsync(aCallers[raw % aCallers.length]());
+      }
+      bCounts.forEach((count, i) => {
+        if (count !== baseline[i]) {
+          throw new Error(`driving instance A perturbed instance B's surface #${i}`);
+        }
+      });
+      bSubs.forEach((s) => s.unsubscribe());
+      a.unit.dispose();
+      b.unit.dispose();
+      a.teardown();
+      b.teardown();
+    }));
+  }
+  if (spec.ownedChildSurfaces) {
+    const { unit, teardown } = fresh();
+    const childSurfaces = spec.ownedChildSurfaces(unit);
+    const completed = childSurfaces.map(() => false);
+    const subs = childSurfaces.map((o, i) => o.subscribe({ complete: () => {
+      completed[i] = true;
+    } }));
+    unit.dispose();
+    completed.forEach((seen, i) => {
+      if (!seen) throw new Error(`A7-owned: owned child surface #${i} did not complete on outer dispose`);
+    });
+    subs.forEach((s) => s.unsubscribe());
+    teardown();
+  }
+  if (spec.surfaces) {
+    const { unit, teardown } = fresh();
+    unit.dispose();
+    spec.surfaces(unit).forEach((o, i) => {
+      let nexts = 0;
+      let done = false;
+      o.subscribe({ next: () => {
+        nexts += 1;
+      }, complete: () => {
+        done = true;
+      } }).unsubscribe();
+      if (nexts > 0) throw new Error(`A5b/inert: owned surface #${i} emitted a value after dispose`);
+      if (!done) throw new Error(`A5b/inert: owned surface #${i} did not complete after dispose`);
+    });
+    teardown();
+  }
+}
+
+// src/branded-types.ts
+function baseUrl(value) {
+  return value;
+}
+
+// src/bus-operations.ts
+var BUS_OPERATIONS = {
+  // ── BIND ────────────────────────────────────────────────────────
+  "bind:update-body": { result: "bind:body-updated", failure: "bind:body-update-failed" },
+  // ── BROWSE (reads) ──────────────────────────────────────────────
+  "browse:resource-requested": { result: "browse:resource-result", failure: "browse:resource-failed" },
+  "browse:resources-requested": { result: "browse:resources-result", failure: "browse:resources-failed" },
+  "browse:annotation-requested": { result: "browse:annotation-result", failure: "browse:annotation-failed" },
+  "browse:annotations-requested": { result: "browse:annotations-result", failure: "browse:annotations-failed" },
+  "browse:annotation-history-requested": { result: "browse:annotation-history-result", failure: "browse:annotation-history-failed" },
+  "browse:events-requested": { result: "browse:events-result", failure: "browse:events-failed" },
+  "browse:referenced-by-requested": { result: "browse:referenced-by-result", failure: "browse:referenced-by-failed" },
+  "browse:entity-types-requested": { result: "browse:entity-types-result", failure: "browse:entity-types-failed" },
+  "browse:tag-schemas-requested": { result: "browse:tag-schemas-result", failure: "browse:tag-schemas-failed" },
+  "browse:agents-requested": { result: "browse:agents-result", failure: "browse:agents-failed" },
+  "browse:directory-requested": { result: "browse:directory-result", failure: "browse:directory-failed" },
+  // dormant — backend handler complete, no client caller yet (annotation-detail capability)
+  "browse:annotation-context-requested": { result: "browse:annotation-context-result", failure: "browse:annotation-context-failed" },
+  // ── FRAME (KB schema writes) ────────────────────────────────────
+  "frame:add-entity-type": { result: "frame:entity-type-add-ok", failure: "frame:entity-type-add-failed" },
+  "frame:add-tag-schema": { result: "frame:tag-schema-add-ok", failure: "frame:tag-schema-add-failed" },
+  // ── GATHER ──────────────────────────────────────────────────────
+  // streaming: take-1 result + failure plus an intermediate progress channel
+  "gather:requested": { result: "gather:complete", failure: "gather:failed", progress: "gather:annotation-progress" },
+  "gather:resource-requested": { result: "gather:resource-complete", failure: "gather:resource-failed" },
+  // dormant — backend handler complete, no client caller yet (annotation summary)
+  "gather:summary-requested": { result: "gather:summary-result", failure: "gather:summary-failed" },
+  // ── JOB ─────────────────────────────────────────────────────────
+  "job:create": { result: "job:created", failure: "job:create-failed" },
+  "job:status-requested": { result: "job:status-result", failure: "job:status-failed" },
+  "job:cancel-requested": { result: "job:cancel-ok", failure: "job:cancel-failed" },
+  // worker-side: the worker claims a queued job (not an SDK call)
+  "job:claim": { result: "job:claimed", failure: "job:claim-failed" },
+  // ── MARK ────────────────────────────────────────────────────────
+  "mark:create-request": { result: "mark:create-ok", failure: "mark:create-failed" },
+  "mark:delete": { result: "mark:delete-ok", failure: "mark:delete-failed" },
+  "mark:archive": { result: "mark:archive-ok", failure: "mark:archive-failed" },
+  "mark:unarchive": { result: "mark:unarchive-ok", failure: "mark:unarchive-failed" },
+  "mark:update-entity-types": { result: "mark:update-entity-types-ok", failure: "mark:update-entity-types-failed" },
+  // ── MATCH ───────────────────────────────────────────────────────
+  // take-1 dressed as an Observable in the SDK; no progress channel
+  "match:search-requested": { result: "match:search-results", failure: "match:search-failed" },
+  // ── YIELD ───────────────────────────────────────────────────────
+  // live in-process (resource-operations.ts emits + awaits via race()); the
+  // client also .on()-subscribes -ok for cache invalidation
+  "yield:create": { result: "yield:create-ok", failure: "yield:create-failed" },
+  // dormant — handler in stower exists, no request emitter; client pre-subscribes -ok
+  "yield:update": { result: "yield:update-ok", failure: "yield:update-failed" },
+  "yield:clone-create": { result: "yield:clone-created", failure: "yield:clone-create-failed" },
+  "yield:clone-resource-requested": { result: "yield:clone-resource-result", failure: "yield:clone-resource-failed" },
+  "yield:clone-token-requested": { result: "yield:clone-token-generated", failure: "yield:clone-token-failed" }
+};
+
+// src/bridged-channels.ts
+var BRIDGED_BROADCASTS = [
+  "job:report-progress",
+  "job:complete",
+  "job:fail",
+  "frame:entity-type-added",
+  "frame:tag-schema-added",
+  "beckon:focus",
+  "beckon:sparkle",
+  "bus:resume-gap"
+];
+var REGISTRY_REPLIES = Object.keys(BUS_OPERATIONS).flatMap(
+  (key) => {
+    const op = BUS_OPERATIONS[key];
+    return "progress" in op ? [op.result, op.failure, op.progress] : [op.result, op.failure];
+  }
+);
+var BRIDGED_CHANNELS = [
+  ...REGISTRY_REPLIES,
+  ...BRIDGED_BROADCASTS
+];
+
+// src/bus-log.ts
+var NODE_BUS_LOG = typeof process !== "undefined" && !!process.env?.SEMIONT_BUS_LOG;
+var IS_NODE = typeof process !== "undefined" && !!process.versions?.node;
+function busLogEnabled() {
+  const g = globalThis;
+  if (g.__SEMIONT_BUS_LOG__) return true;
+  return NODE_BUS_LOG;
+}
+function busLog(op, channel, payload, scope) {
+  if (!busLogEnabled()) return;
+  const cidRaw = payload?.correlationId;
+  const cid = typeof cidRaw === "string" ? cidRaw.slice(0, 8) : void 0;
+  const tag = `[bus ${op}] ${channel}` + ("") + (cid ? ` cid=${cid}` : "") + ("");
+  console.debug(tag, payload);
+}
+function warnUnobservedRepliesEnabled() {
+  return IS_NODE;
+}
+var unobservedReplyWarned = /* @__PURE__ */ new Set();
+function warnIfUnobservedReply(channel, payload, observerCount) {
+  if (observerCount > 0) return;
+  const cidRaw = payload?.correlationId;
+  if (typeof cidRaw !== "string" || cidRaw.length === 0) return;
+  if (BRIDGED_CHANNELS.includes(channel)) return;
+  if (unobservedReplyWarned.has(channel)) return;
+  unobservedReplyWarned.add(channel);
+  console.warn(
+    `[bus DROP] ${channel} cid=${cidRaw.slice(0, 8)} emitted with 0 subscribers and not in BRIDGED_CHANNELS \u2014 a correlation reply with no forwarder is dropped, so the awaiting client times out (no error). Bridge it by declaring its operation in BUS_OPERATIONS (packages/core/src/bus-operations.ts) \u2014 or, if it is a non-reply broadcast, add it to BRIDGED_BROADCASTS (packages/core/src/bridged-channels.ts) \u2014 so transports subscribe to it.`
+  );
+}
+
+// src/event-bus.ts
+var EventBus = class {
+  subjects;
+  isDestroyed;
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+  }
+  /**
+   * Get the RxJS Subject for an event
+   *
+   * Returns a typed Subject that can be used with all RxJS operators.
+   * Subjects are created lazily on first access.
+   *
+   * @param eventName - The event name
+   * @returns The RxJS Subject for this event
+   *
+   * @example
+   * ```typescript
+   * // Emit
+   * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
+   *
+   * // Subscribe
+   * const sub = eventBus.get('beckon:hover').subscribe(handleHover);
+   *
+   * // With operators
+   * eventBus.get('beckon:hover')
+   *   .pipe(debounceTime(100), distinctUntilChanged())
+   *   .subscribe(handleHover);
+   * ```
+   */
+  get(eventName) {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot access event '${String(eventName)}' on destroyed bus`);
+    }
+    if (!this.subjects.has(eventName)) {
+      const subject = new Subject();
+      const wantBusLog = busLogEnabled();
+      const wantDropCheck = warnUnobservedRepliesEnabled();
+      if (wantBusLog || wantDropCheck) {
+        const wrapped = subject;
+        const originalNext = subject.next.bind(subject);
+        subject.next = (value) => {
+          if (wantBusLog) busLog("EMIT", String(eventName), value);
+          if (wantDropCheck) warnIfUnobservedReply(String(eventName), value, wrapped.observers.length);
+          originalNext(value);
+        };
+      }
+      this.subjects.set(eventName, subject);
+    }
+    return this.subjects.get(eventName);
+  }
+  /**
+   * Get the RxJS Subject for a domain event type (PersistedEventType).
+   *
+   * Domain event channels carry `StoredEvent`. This method avoids the need
+   * for `as keyof EventMap` casts when subscribing to domain event channels
+   * using runtime `PersistedEventType` strings.
+   */
+  getDomainEvent(eventType) {
+    return this.get(eventType);
+  }
+  /**
+   * Destroy the event bus and complete all subjects
+   *
+   * After calling destroy(), no new events can be emitted or subscribed to.
+   * All active subscriptions will be completed.
+   */
+  destroy() {
+    if (this.isDestroyed) {
+      return;
+    }
+    for (const subject of this.subjects.values()) {
+      subject.complete();
+    }
+    this.subjects.clear();
+    this.isDestroyed = true;
+  }
+  /**
+   * Check if the event bus has been destroyed
+   */
+  get destroyed() {
+    return this.isDestroyed;
+  }
+  /**
+   * Create a resource-scoped event bus
+   *
+   * Events emitted or subscribed through the scoped bus are isolated to that resource.
+   * Internally, events are namespaced but the API remains identical to the parent bus.
+   *
+   * @param resourceId - Resource identifier to scope events to
+   * @returns A scoped event bus for this resource
+   *
+   * @example
+   * ```typescript
+   * const eventBus = new EventBus();
+   * const resource1 = eventBus.scope('resource-1');
+   * const resource2 = eventBus.scope('resource-2');
+   *
+   * // These are isolated - only resource1 subscribers will fire
+   * resource1.get('detection:progress').next({ status: 'started' });
+   * ```
+   */
+  scope(resourceId) {
+    return new ScopedEventBus(this, resourceId);
+  }
+};
+var ScopedEventBus = class _ScopedEventBus {
+  constructor(parent, scopePrefix) {
+    this.parent = parent;
+    this.scopePrefix = scopePrefix;
+  }
+  parent;
+  scopePrefix;
+  /**
+   * Get the RxJS Subject for a scoped event
+   *
+   * Returns the same type as the parent bus, but events are isolated to this scope.
+   * Internally uses namespaced keys but preserves type safety.
+   *
+   * @param event - The event name
+   * @returns The RxJS Subject for this scoped event
+   */
+  get(event) {
+    const scopedKey = `${this.scopePrefix}:${event}`;
+    const parentSubjects = this.parent.subjects;
+    if (!parentSubjects.has(scopedKey)) {
+      parentSubjects.set(scopedKey, new Subject());
+    }
+    return parentSubjects.get(scopedKey);
+  }
+  /** Get the RxJS Subject for a domain event type on this scoped bus. */
+  getDomainEvent(eventType) {
+    return this.get(eventType);
+  }
+  /**
+   * Create a nested scope
+   *
+   * Allows hierarchical scoping like `resource-1:subsystem-a`
+   *
+   * @param subScope - Additional scope level
+   * @returns A nested scoped event bus
+   */
+  scope(subScope) {
+    return new _ScopedEventBus(this.parent, `${this.scopePrefix}:${subScope}`);
+  }
+};
+
+// src/faulty-transport.ts
+function isOperation(channel) {
+  return channel in BUS_OPERATIONS;
+}
+function retryKeyOf(channel, payload) {
+  const entries = Object.entries(payload).filter(([k]) => k !== "correlationId" && k !== "_trace" && k !== "_userId").sort(([a], [b]) => a < b ? -1 : 1);
+  return `${channel} ${JSON.stringify(entries)}`;
+}
+var FaultyTransport = class {
+  baseUrl = baseUrl("faulty://simulator");
+  state$ = new BehaviorSubject("open");
+  errorsSubject = new Subject();
+  errors$ = this.errorsSubject.asObservable();
+  /** Every request-channel emit, in order — the L2 accounting surface. */
+  requestLog = [];
+  bus = new EventBus();
+  schedule;
+  scopeModel;
+  makeResponse;
+  requestCount = 0;
+  activeScope = null;
+  scopeRefs = 0;
+  timers = /* @__PURE__ */ new Set();
+  disposed = false;
+  constructor(cfg = {}) {
+    this.schedule = cfg.schedule ?? [];
+    this.scopeModel = cfg.scopeModel ?? "single-slot-throw";
+    this.makeResponse = cfg.makeResponse ?? (() => ({}));
+  }
+  // ── Bus primitives ──────────────────────────────────────────────────────
+  async emit(channel, payload, resourceScope) {
+    if (this.disposed) return;
+    const name = channel;
+    if (!isOperation(name)) {
+      const target = resourceScope === void 0 ? this.bus.get(channel) : this.bus.scope(resourceScope).get(channel);
+      target.next(payload);
+      return;
+    }
+    const record = payload;
+    const action = this.schedule.length === 0 ? { kind: "deliver" } : this.schedule[this.requestCount % this.schedule.length];
+    this.requestCount += 1;
+    this.requestLog.push({
+      channel: name,
+      action,
+      correlationId: typeof record.correlationId === "string" ? record.correlationId : void 0,
+      retryKey: retryKeyOf(name, record)
+    });
+    if (action.kind === "reject-emit") {
+      throw new Error(`FaultyTransport: emit rejected by schedule (reject-emit) on ${name}`);
+    }
+    this.bus.get(channel).next(payload);
+    const reply = () => {
+      if (this.disposed) return;
+      const response = this.makeResponse(name, record);
+      const replyPayload = response === void 0 ? { correlationId: record.correlationId } : { correlationId: record.correlationId, response };
+      const resultChannel = BUS_OPERATIONS[name].result;
+      this.bus.get(resultChannel).next(replyPayload);
+    };
+    switch (action.kind) {
+      case "deliver":
+        queueMicrotask(reply);
+        break;
+      case "duplicate-reply":
+        queueMicrotask(reply);
+        queueMicrotask(reply);
+        break;
+      case "delay": {
+        const t = setTimeout(() => {
+          this.timers.delete(t);
+          reply();
+        }, action.ms);
+        this.timers.add(t);
+        break;
+      }
+    }
+  }
+  on(channel, handler) {
+    const sub = this.bus.get(channel).subscribe(handler);
+    return () => sub.unsubscribe();
+  }
+  stream(channel) {
+    return this.bus.get(channel);
+  }
+  subscribeToResource(rid) {
+    const scope = rid;
+    if (this.scopeModel === "single-slot-throw" && this.activeScope !== null && this.activeScope !== scope) {
+      throw new Error(
+        `FaultyTransport: scope slot busy (${this.activeScope}); unsubscribe before subscribing to ${scope} (scopeModel=single-slot-throw)`
+      );
+    }
+    this.activeScope = this.activeScope ?? scope;
+    this.scopeRefs += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.scopeRefs -= 1;
+      if (this.scopeRefs === 0) this.activeScope = null;
+    };
+  }
+  bridgeInto(bus) {
+    for (const channel of BRIDGED_CHANNELS) {
+      this.bus.get(channel).subscribe((payload) => {
+        bus.get(channel).next(payload);
+      });
+    }
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const t of this.timers) clearTimeout(t);
+    this.timers.clear();
+    this.state$.next("closed");
+    this.state$.complete();
+    this.errorsSubject.complete();
+    this.bus.destroy();
+  }
+};
+function arbFaultAction() {
+  return fc2.oneof(
+    fc2.constant({ kind: "deliver" }),
+    fc2.constant({ kind: "drop-reply" }),
+    fc2.integer({ min: 0, max: 5 }).map((ms) => ({ kind: "delay", ms })),
+    fc2.constant({ kind: "duplicate-reply" }),
+    fc2.constant({ kind: "reject-emit" })
+  );
+}
+function arbFaultSchedule(maxLength = 8) {
+  return fc2.array(arbFaultAction(), { minLength: 1, maxLength });
+}
+function describeSchedule(schedule) {
+  return schedule.map((a) => a.kind === "delay" ? `delay(${a.ms})` : a.kind).join(",");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runLabeled(fallback, slot, assertion) {
+  try {
+    await assertion();
+  } catch (e) {
+    const detail = e instanceof Error ? e.message : String(e);
+    if (slot.violation) throw new Error(`${slot.violation.message}
+${detail}`);
+    throw new Error(`${fallback}: ${detail}`);
+  }
+}
+function capturing(slot, block) {
+  try {
+    block();
+  } catch (e) {
+    slot.violation = e instanceof Error ? e : new Error(String(e));
+    throw e;
+  }
+}
+async function assertLivenessAxioms(spec) {
+  const retryBudget = spec.retryBudget ?? 1;
+  const slack = spec.slackFactor ?? 4;
+  const scheduleArb = spec.scheduleArb ?? arbFaultSchedule();
+  const scopeArb = spec.scopeModel === "both" ? fc2.constantFrom("single-slot-throw", "multi") : fc2.constant(spec.scopeModel ?? "single-slot-throw");
+  const slot = { violation: null };
+  await runLabeled(
+    "liveness",
+    slot,
+    () => fc2.assert(
+      fc2.asyncProperty(scheduleArb, scopeArb, async (schedule, scopeModel) => {
+        const delayTotal = schedule.reduce((n, a) => n + (a.kind === "delay" ? a.ms : 0), 0);
+        const bound = (spec.timeoutMs * (1 + retryBudget) + delayTotal) * slack;
+        const transport = new FaultyTransport({
+          schedule,
+          scopeModel,
+          ...spec.makeResponse ? { makeResponse: spec.makeResponse } : {}
+        });
+        const scenario = await spec.setup(transport);
+        const outputs = scenario.outputs;
+        const settlements = scenario.settlements ?? [];
+        const notified = outputs.map(() => false);
+        const settled = settlements.map(() => false);
+        let doneResolve = () => {
+        };
+        const allDone = new Promise((resolve) => {
+          doneResolve = resolve;
+        });
+        const check = () => {
+          if (notified.every(Boolean) && settled.every(Boolean)) doneResolve();
+        };
+        const subs = outputs.map(
+          (o, i) => o.subscribe({
+            next: () => {
+              notified[i] = true;
+              check();
+            },
+            error: () => {
+              notified[i] = true;
+              check();
+            }
+          })
+        );
+        settlements.forEach((p, i) => {
+          p.then(
+            () => {
+              settled[i] = true;
+              check();
+            },
+            () => {
+              settled[i] = true;
+              check();
+            }
+          );
+        });
+        check();
+        await Promise.race([allDone, sleep(bound)]);
+        try {
+          capturing(slot, () => {
+            settled.forEach((seen, i) => {
+              if (!seen) {
+                throw new Error(
+                  `L2: settlement #${i} did not settle within ${bound}ms under schedule \u27E8${describeSchedule(schedule)}\u27E9 \u2014 the forbidden fourth state`
+                );
+              }
+            });
+            const issues = /* @__PURE__ */ new Map();
+            for (const entry of transport.requestLog) {
+              const prior = issues.get(entry.retryKey) ?? { count: 0, lastFaulted: false };
+              issues.set(entry.retryKey, {
+                count: prior.count + 1,
+                lastFaulted: entry.action.kind === "drop-reply" || entry.action.kind === "reject-emit"
+              });
+            }
+            for (const [key, { count, lastFaulted }] of issues) {
+              if (count > 1 + retryBudget) {
+                throw new Error(
+                  `L2: request \u27E8${key}\u27E9 issued ${count} times \u2014 exceeds the retry budget (1 + ${retryBudget}) under schedule \u27E8${describeSchedule(schedule)}\u27E9`
+                );
+              }
+              if (lastFaulted && count <= retryBudget && outputs.length > 0 && !notified.some(Boolean)) {
+                throw new Error(
+                  `L2: faulted request \u27E8${key}\u27E9 was neither re-issued nor surfaced under schedule \u27E8${describeSchedule(schedule)}\u27E9 \u2014 rejection swallowed`
+                );
+              }
+            }
+            notified.forEach((seen, i) => {
+              if (!seen) {
+                throw new Error(
+                  `L1: output #${i} received no next/error within ${bound}ms under schedule \u27E8${describeSchedule(schedule)}\u27E9 (scope=${scopeModel}) \u2014 silently pending`
+                );
+              }
+            });
+          });
+        } finally {
+          subs.forEach((s) => s.unsubscribe());
+          scenario.teardown?.();
+          transport.dispose();
+        }
+      }),
+      { numRuns: spec.numRuns ?? 25 }
+    )
+  );
+}
+function arbDeliveryOps(maxOps = 12) {
+  return fc2.array(fc2.constantFrom("write", "transition"), { minLength: 1, maxLength: maxOps }).map((ops) => ops.includes("write") ? ops : [...ops, "write"]);
+}
+async function assertExactlyOnceDelivery(spec) {
+  const opsArb = spec.opsArb ?? arbDeliveryOps(spec.maxOps ?? 12);
+  const slot = { violation: null };
+  await runLabeled(
+    "L3",
+    slot,
+    () => fc2.assert(
+      fc2.asyncProperty(opsArb, async (ops) => {
+        const subject = spec.setup();
+        const delivered = [];
+        const sub = subject.output$.subscribe((id) => delivered.push(id));
+        const written = [];
+        try {
+          for (let i = 0; i < ops.length; i++) {
+            if (ops[i] === "write") {
+              const id = `e${i}`;
+              written.push(id);
+              subject.write(id);
+            } else {
+              await subject.transition();
+            }
+          }
+          await (subject.settle?.() ?? sleep(0));
+          capturing(slot, () => {
+            for (const id of written) {
+              const n = delivered.filter((d) => d === id).length;
+              if (n === 0) {
+                throw new Error(
+                  `L3: event \u27E8${id}\u27E9 delivered 0 times under \u27E8${ops.join(",")}\u27E9 \u2014 lost across a transition (retire by drain, never by abort)`
+                );
+              }
+              if (n > 1) {
+                throw new Error(
+                  `L3: event \u27E8${id}\u27E9 delivered ${n} times under \u27E8${ops.join(",")}\u27E9 \u2014 duplicate delivery`
+                );
+              }
+            }
+          });
+        } finally {
+          sub.unsubscribe();
+          subject.teardown?.();
+        }
+      }),
+      { numRuns: spec.numRuns ?? 50 }
+    )
+  );
+}
+
+export { FaultyTransport, arbDeliveryOps, arbFaultAction, arbFaultSchedule, assertExactlyOnceDelivery, assertLivenessAxioms, assertStateUnitAxioms, disposeProbe, retryKeyOf };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map