@sensigo/realm-testing 0.26.0 → 0.28.0

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { perRunArtifactStoreContract } from './store/per-run-artifact-store-cont
 export type { ArtifactStoreLaw, ArtifactStoreContractCase, PerRunArtifactStoreContractAdapter, } from './store/per-run-artifact-store-contract.js';
 export { runStoreFidelityContract } from './store/run-store-fidelity-contract.js';
 export type { RunStoreFidelityLaw, RunStoreFidelityContractCase, RunStoreFidelityContractAdapter, } from './store/run-store-fidelity-contract.js';
+export { fencedTraceBufferContract } from './store/fenced-trace-buffer-contract.js';
+export type { FencedTraceBufferLaw, FencedTraceBufferContractCase, FencedTraceBufferContractAdapter, } from './store/fenced-trace-buffer-contract.js';
 export { loadFixtureFromFile, loadFixtureFromString, loadFixturesFromDir, } from './fixtures/fixture-loader.js';
 export type { TestFixture, MockOperations } from './fixtures/fixture-loader.js';
 export { MockServiceRecorder } from './mocks/mock-service.js';
@@ -17,5 +19,5 @@ export { runFixtureTests } from './runner/test-runner.js';
 export type { TestResult, RunFixtureTestsOptions } from './runner/test-runner.js';
 export { startGitHubMockServer } from './servers/github-mock-server.js';
 export type { GitHubMockServerHandle } from './servers/github-mock-server.js';
-export declare const VERSION = "0.26.0";
+export declare const VERSION = "0.28.0";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,YAAY,EACV,gBAAgB,EAChB,yBAAyB,EACzB,kCAAkC,GACnC,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,YAAY,EACV,mBAAmB,EACnB,4BAA4B,EAC5B,+BAA+B,GAChC,MAAM,wCAAwC,CAAC;AAGhD,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,YAAY,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E,eAAO,MAAM,OAAO,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,YAAY,EACV,gBAAgB,EAChB,yBAAyB,EACzB,kCAAkC,GACnC,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,YAAY,EACV,mBAAmB,EACnB,4BAA4B,EAC5B,+BAA+B,GAChC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,YAAY,EACV,oBAAoB,EACpB,6BAA6B,EAC7B,gCAAgC,GACjC,MAAM,yCAAyC,CAAC;AAGjD,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,YAAY,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E,eAAO,MAAM,OAAO,WAAW,CAAC"}

package/dist/index.js

@@ -3,6 +3,7 @@
 export { InMemoryStore } from './store/in-memory-store.js';
 export { perRunArtifactStoreContract } from './store/per-run-artifact-store-contract.js';
 export { runStoreFidelityContract } from './store/run-store-fidelity-contract.js';
+export { fencedTraceBufferContract } from './store/fenced-trace-buffer-contract.js';
 // Fixtures
 export { loadFixtureFromFile, loadFixtureFromString, loadFixturesFromDir, } from './fixtures/fixture-loader.js';
 // Mocks
@@ -19,5 +20,5 @@ export { testAdapter } from './helpers/test-adapter.js';
 export { runFixtureTests } from './runner/test-runner.js';
 // Servers
 export { startGitHubMockServer } from './servers/github-mock-server.js';
-export const VERSION = '0.26.0';
+export const VERSION = '0.28.0';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AAEjE,QAAQ;AACR,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAMzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAOlF,WAAW;AACX,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AAGtC,QAAQ;AACR,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,aAAa;AACb,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,oBAAoB;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,SAAS;AACT,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D,UAAU;AACV,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AAEjE,QAAQ;AACR,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAMzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAMlF,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAOpF,WAAW;AACX,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AAGtC,QAAQ;AACR,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,aAAa;AACb,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,oBAAoB;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,SAAS;AACT,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D,UAAU;AACV,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC"}

package/dist/store/fenced-trace-buffer-contract.d.ts

@@ -0,0 +1,87 @@
+import { type TraceBufferStore } from '@sensigo/realm';
+/**
+ * One of the laws every fenced-trio-declaring `TraceBufferStore` must satisfy. The original five
+ * (issue #207) cover the fenced trio itself; the remaining five (issue #197 PR-1) cover the
+ * optional capability-ladder rungs a trio-declaring store MAY additionally declare (`seal` and
+ * `writer_nonce_carriage`) — each of those five produces an explicit, VISIBLE documented-skip case
+ * (never a silent omission) for a store that does not declare the relevant rung, mirroring the
+ * `fenceForm: 'native-predicate'` skip precedent already established for the latch-based trio
+ * laws below.
+ */
+export type FencedTraceBufferLaw = 'STRUCTURAL' | 'FENCE_REFUSES' | 'CS_OCCUPANCY' | 'PER_KEY_INDEPENDENCE' | 'NO_SILENT_LOSS' | 'CARRIAGE_ROUND_TRIP' | 'SEAL' | 'SEAL_BUDGET' | 'PER_WRITER_BUDGET' | 'VERBATIM';
+/**
+ * A single, framework-agnostic contract case. `run()` throws (rejects) on failure — any test
+ * framework's `await run()` (rejecting fails the test) or `expect(run()).resolves...` /
+ * `expect(run()).rejects...` maps directly onto this.
+ */
+export interface FencedTraceBufferContractCase {
+    law: FencedTraceBufferLaw;
+    name: string;
+    run: () => Promise<void>;
+}
+/** Adapter a calling test file supplies to parameterize the contract against one concrete store. */
+export interface FencedTraceBufferContractAdapter {
+    /** The store under test — already declaring the fenced trio (`appendFenced`/`deleteFenced`/
+     *  `deleteAllForRunFenced`). For `fenceForm: 'guard-in-cs'` stores, this instance should already
+     *  be constructed with a sufficiently generous lock-acquisition profile (see `lockProfile`
+     *  below) so a deliberately-parked guard in the latch-based laws doesn't cause a concurrent
+     *  caller's own acquisition attempt to give up before the law's observation window completes. */
+    store: TraceBufferStore;
+    /** Returns a fresh, never-before-used (runId, stepId) pair for one case — callers should treat
+     *  every returned pair as belonging to a disjoint run from every other pair this returns. */
+    makeKey: () => {
+        runId: string;
+        stepId: string;
+    };
+    /**
+     * `'guard-in-cs'`: the store enforces the fence via an in-process critical section — the guard
+     * literally runs inside the same lock/mutex the destructive effect does. `'native-predicate'`:
+     * the store enforces the fence via a transaction-scoped SQL predicate instead (e.g. a future
+     * Postgres store) — the latch-based laws (`CS_OCCUPANCY`, `PER_KEY_INDEPENDENCE`,
+     * `NO_SILENT_LOSS`) do not apply to this fence form and produce an explicit, VISIBLE
+     * documented-skip case rather than a silent omission. **A green TCK run does NOT verify race
+     * closure for a native-predicate store** — that store's own in-transaction fencing suite must
+     * (the same posture `RunStore.claimStep`'s cross-host obligation already states for
+     * `CLAIM_SINGLE_OWNER`, issue #188).
+     */
+    fenceForm: 'guard-in-cs' | 'native-predicate';
+    /** Descriptive only (present for `'guard-in-cs'` adapters): the lock-acquisition profile the
+     *  `store` instance above was actually constructed with, for the calling test file's own
+     *  documentation — the TCK itself does not need to act on this value; it exists so a wiring
+     *  test can assert (and a reader can see) that a genuinely generous profile is in use. */
+    lockProfile?: unknown;
+    /**
+     * Per-adapter byte oracle for `PER_WRITER_BUDGET` (issue #197 PR-1) — since the in-memory and fs
+     * stores compute "bytes" via genuinely different formulas (whole-array restringify vs
+     * JSONL-additive), this TCK can only assert exact ENTRY COUNTS store-agnostically; exact BYTE
+     * equality needs each adapter to supply its own oracle, computed however that concrete store's
+     * own `AppendResult.buffer_bytes`/`file_bytes` are actually derived. Optional — a store without
+     * this hook still runs every count-based `PER_WRITER_BUDGET` assertion; only the byte-exactness
+     * sub-assertion is skipped (visibly, never silently) for that adapter.
+     */
+    bytesOracle?: (runId: string, stepId: string, writerNonce: string | undefined) => Promise<{
+        count: number;
+        bytes: number;
+    }>;
+    /**
+     * fs-scoped raw on-disk byte access for `VERBATIM` (issue #197 PR-1) — reads the RAW bytes of a
+     * live WAL path and of one sealed artifact (`seq`), so the law can assert a seal moves bytes
+     * byte-for-byte (no parse/re-copy/truncation/dedup). `undefined` from either function means "no
+     * file at that path" (mirrors `readIfExists`'s absence convention). Optional — a store without
+     * this hook (e.g. the in-memory store, which has no on-disk representation at all) skips ONLY
+     * the raw-byte-exactness case; the shape-tolerant sibling case still runs unconditionally for
+     * every `seal`-declaring store.
+     */
+    rawWalAccess?: {
+        readLiveRaw: (runId: string, stepId: string) => Promise<string | undefined>;
+        readSealedRaw: (runId: string, stepId: string, seq: number) => Promise<string | undefined>;
+    };
+}
+/**
+ * Builds the contract cases for `adapter`. See each law's own doc above (the `build*Case`
+ * functions) for what it asserts. For `fenceForm: 'native-predicate'` adapters, `CS_OCCUPANCY`,
+ * `PER_KEY_INDEPENDENCE`, and `NO_SILENT_LOSS` are replaced with an explicit, VISIBLE
+ * documented-skip case each (never a silent omission) — see the adapter's own `fenceForm` doc.
+ */
+export declare function fencedTraceBufferContract(adapter: FencedTraceBufferContractAdapter): FencedTraceBufferContractCase[];
+//# sourceMappingURL=fenced-trace-buffer-contract.d.ts.map

package/dist/store/fenced-trace-buffer-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fenced-trace-buffer-contract.d.ts","sourceRoot":"","sources":["../../src/store/fenced-trace-buffer-contract.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,gBAAgB,EAStB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,GAC5B,YAAY,GACZ,eAAe,GACf,cAAc,GACd,sBAAsB,GACtB,gBAAgB,GAChB,qBAAqB,GACrB,MAAM,GACN,aAAa,GACb,mBAAmB,GACnB,UAAU,CAAC;AAEf;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,oBAAoB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,oGAAoG;AACpG,MAAM,WAAW,gCAAgC;IAC/C;;;;qGAIiG;IACjG,KAAK,EAAE,gBAAgB,CAAC;IACxB;iGAC6F;IAC7F,OAAO,EAAE,MAAM;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD;;;;;;;;;;OAUG;IACH,SAAS,EAAE,aAAa,GAAG,kBAAkB,CAAC;IAC9C;;;8FAG0F;IAC1F,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,CACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,KAC5B,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE/C;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE;QACb,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;QAC5E,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;KAC5F,CAAC;CACH;AAk1BD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,6BAA6B,EAAE,CAuVjC"}

package/dist/store/fenced-trace-buffer-contract.js

@@ -0,0 +1,970 @@
+// fenced-trace-buffer-contract.ts — framework-agnostic Test Compatibility Kit (TCK) for the
+// TraceBufferStore fenced trio (issue #207, converged design D3 — plans/issue-207-design-d3.md
+// in the realm repo).
+//
+// Pure case descriptors, NOT describe/it/expect — mirrors per-run-artifact-store-contract.ts's
+// and run-store-fidelity-contract.ts's own precedent (importing vitest here would make it a
+// runtime dependency of this published package). Each calling test file supplies an adapter and
+// wires the returned descriptors into ITS OWN test framework.
+//
+// The choreography for CS_OCCUPANCY and NO_SILENT_LOSS is deadlock-free BY CONSTRUCTION (D3 §7 is
+// normative — implemented here as written, not improvised): every parked promise has a `.catch`
+// attached before the law ever awaits anything else, the "drain" step never depends on the
+// latched call's own settlement, and the latch is always released before the law awaits the
+// latched call's result.
+import { WorkflowError, FsIoError, storeDeclaresSeal, storeDeclaresNonceCarriage, validateTraceCapabilities, BUFFER_LIMIT_COUNT, BUFFER_BACKSTOP_COUNT, SEALED_ARTIFACTS_LIMIT_PER_STEP, } from '@sensigo/realm';
+const REFUSAL_CODE = 'STATE_RUN_BUSY';
+/** A guard that always refuses with a typed, populated-category rejection — used by every
+ *  FENCE_REFUSES case. Deliberately a real `WorkflowError` (not a bare `Error`) so the law can
+ *  assert the reason category actually propagates, not just "something" propagates. */
+function refusingGuard() {
+    return async () => {
+        throw new WorkflowError('fenced-tck: guard refused (simulated)', {
+            code: REFUSAL_CODE,
+            category: 'STATE',
+            agentAction: 'report_to_user',
+            retryable: true,
+        });
+    };
+}
+function passingGuard() {
+    return async () => { };
+}
+/**
+ * A minimal, otherwise-legal `TraceBufferStore` STUB (issue #197 PR-1) — implements only the four
+ * mandatory legacy methods (never actually called by these cases) plus a HAND-SET
+ * `traceCapabilities`, deliberately WITHOUT any of the fenced-trio/seal methods regardless of what
+ * `caps` declares. Used exclusively to exercise `validateTraceCapabilities` against a
+ * declared-but-inconsistent shape — never mixed with the real adapter store, which always
+ * satisfies its OWN declaration (see the "internally consistent" STRUCTURAL case instead).
+ */
+function minimalStubStore(caps) {
+    return {
+        ...(caps !== undefined ? { traceCapabilities: caps } : {}),
+        append: async () => ({
+            buffer_count: 0,
+            buffer_bytes: 0,
+            limit_count: 0,
+            limit_bytes: 0,
+            final_limit_entries: 0,
+            final_limit_bytes: 0,
+        }),
+        read: async () => [],
+        delete: async () => { },
+        deleteAllForRun: async () => { },
+        readAllForRun: async () => ({}),
+    };
+}
+/** Runs a SYNCHRONOUS throwing function and returns what it threw, or `undefined` if it didn't —
+ *  `validateTraceCapabilities` is synchronous, so this avoids an unnecessary async try/catch at
+ *  every call site above. */
+function catchSync(fn) {
+    try {
+        fn();
+        return undefined;
+    }
+    catch (err) {
+        return err;
+    }
+}
+/** Asserts `err` is exactly the typed `TRACE_CAPABILITY_INCONSISTENT` `WorkflowError`
+ *  `validateTraceCapabilities` throws for a declared-but-inconsistent rung, naming `capability` in
+ *  its `details` — never some other error shape. */
+function assertCapabilityInconsistent(err, capability) {
+    if (!(err instanceof WorkflowError) ||
+        err.code !== 'TRACE_CAPABILITY_INCONSISTENT' ||
+        err.details.capability !== capability) {
+        throw new Error(`expected a typed WorkflowError(TRACE_CAPABILITY_INCONSISTENT, details.capability=${capability}), got: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function eventsOf(entries) {
+    return entries.map((e) => e.event);
+}
+function assertDeepEqualEvents(actual, expected, label) {
+    const a = eventsOf(actual);
+    const e = eventsOf(expected);
+    const equal = a.length === e.length && a.every((v, i) => v === e[i]);
+    if (!equal) {
+        throw new Error(`${label}: expected events ${JSON.stringify(e)}, got ${JSON.stringify(a)}`);
+    }
+}
+/**
+ * Forces the event loop / I/O queue to advance without a fixed wall-clock sleep and without
+ * depending on the latched call's own settlement: ≥5 awaited round-trips of `store.read` against
+ * a DISJOINT sentinel key (never written by any other case), plus one trailing `setImmediate`
+ * (D3 §7's normative drain). Used before checking a latch-based law's "Phase 1" (occupancy)
+ * assertion.
+ */
+async function drain(store) {
+    const sentinelRunId = `fenced-tck-sentinel-run-${Math.random().toString(36).slice(2)}`;
+    for (let i = 0; i < 5; i++) {
+        await store.read(sentinelRunId, 'fenced-tck-sentinel-step');
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+}
+/** A guard that signals when it has been entered (parked) and blocks on an externally-released
+ *  latch — the core primitive both CS_OCCUPANCY and PER_KEY_INDEPENDENCE latch a CS open with. */
+function makeLatch() {
+    let releaseFn;
+    const latchPromise = new Promise((resolve) => {
+        releaseFn = resolve;
+    });
+    let enteredResolve;
+    const entered = new Promise((resolve) => {
+        enteredResolve = resolve;
+    });
+    const guard = async () => {
+        enteredResolve();
+        await latchPromise;
+    };
+    return {
+        guard,
+        entered,
+        release: () => releaseFn(),
+    };
+}
+/** Settlement outcome recorder — lets a law check "has this promise ALREADY settled" without
+ *  awaiting it (which would just wait for eventual settlement, defeating the point of checking a
+ *  point-in-time occupancy snapshot after `drain`). The recorder promise itself is pre-attached
+ *  with a no-op catch so an eventual rejection observed only for BOOKKEEPING never produces an
+ *  unhandled-rejection warning. */
+function recordSettlement(p) {
+    let state = 'pending';
+    let capturedError;
+    p.then(() => {
+        state = 'fulfilled';
+    }, (err) => {
+        state = 'rejected';
+        capturedError = err;
+    });
+    return { outcome: () => state, error: () => capturedError };
+}
+/** Starts `holder` latched open on (runId, stepId), returning the parked promise + latch handle.
+ *  Every fenced method requires an existing store to hold — for delete/deleteAllForRunFenced, the
+ *  key is pre-seeded with a throwaway entry (the specific content doesn't matter; only that the
+ *  operation has something to act on). */
+async function startLatchedHolder(store, holder, runId, stepId, entriesForAppend) {
+    const latch = makeLatch();
+    let parkedP;
+    if (holder === 'appendFenced') {
+        parkedP = store.appendFenced(runId, stepId, entriesForAppend, latch.guard);
+    }
+    else if (holder === 'deleteFenced') {
+        parkedP = store.deleteFenced(runId, stepId, latch.guard);
+    }
+    else {
+        parkedP = store.deleteAllForRunFenced(runId, latch.guard);
+    }
+    await latch.entered;
+    return { parkedP, latch };
+}
+/**
+ * Builds the CS_OCCUPANCY case for one `holder` kind (issue #207, D3 §7).
+ *
+ * Honest guarantee this law provides (issue #207 correction): it is deterministic-no-false-red —
+ * a conforming store can never fail it by bad luck, only a genuinely non-serializing store fails
+ * it. It is NOT deterministic-no-false-green against every possible violator: a store whose
+ * read/delete merely SKIP the lock (rather than sharing no critical section at all) can, on a
+ * sufficiently loaded machine, false-green here — the lock-skipping concurrent call may simply
+ * not have reached its own I/O completion yet when the Phase-1 assertion runs, even though it
+ * never actually respected the CS. An in-memory (synchronous-scheduling) violator has no such
+ * escape and reddens deterministically. Empirically (mutation probe (b), issue #207 correction),
+ * the fs store's own lock-skipping mutation reddened deterministically 5/5 runs on a fast,
+ * unloaded machine — this does not contradict the caveat above; it shows the false-green risk is
+ * a loaded/slow-environment concern, not a claim that the fs law usually (or ever, on a given
+ * machine) false-greens.
+ *
+ * The single-waiter subcase (`buildCsOccupancySingleWaiterCase`, below) is this law's
+ * probabilistic net against a "CS-split" store — one that releases its lock/CS handle before the
+ * write it guards has actually completed (write-after-release). Such a store could conceivably
+ * survive the multi-op Phase 1 above by chance (three concurrent operations racing the same
+ * narrow post-release window), but a single, isolated concurrent read is a comparatively larger
+ * fraction of that same window to land inside — raising, not guaranteeing, the odds of catching a
+ * CS-split violator. Like the caveat above, this is a probabilistic, not deterministic, net.
+ */
+function buildCsOccupancyCase(adapter, holder) {
+    return {
+        law: 'CS_OCCUPANCY',
+        name: `${holder} holding the CS: concurrent read/delete/deleteAllForRun neither succeed during occupancy nor corrupt state after release`,
+        run: async () => {
+            const { store } = adapter;
+            const { runId, stepId } = adapter.makeKey();
+            const B1 = [{ event: 'b1-e0' }, { event: 'b1-e1' }];
+            await store.append(runId, stepId, B1);
+            const B2 = [{ event: 'b2-e0' }];
+            const { parkedP, latch } = await startLatchedHolder(store, holder, runId, stepId, B2);
+            const readP = store.read(runId, stepId);
+            const deleteP = store.delete(runId, stepId);
+            const deleteAllP = store.deleteAllForRun(runId);
+            // Attach catches BEFORE draining — deadlock/unhandled-rejection-free by construction.
+            const readRec = recordSettlement(readP.catch((e) => Promise.reject(e)));
+            const deleteRec = recordSettlement(deleteP.catch((e) => Promise.reject(e)));
+            const deleteAllRec = recordSettlement(deleteAllP.catch((e) => Promise.reject(e)));
+            await drain(store);
+            // Phase 1 (occupancy): NONE of the three may have completed SUCCESSFULLY yet — still
+            // pending, or ANY rejection (not just a typed lock-contention error), both conform.
+            // Immediate success is the deterministic red. Tolerating any rejection type here (wider
+            // than requiring a specific typed lock-contention error) is deliberate (issue #207
+            // correction): widening what counts as "conforming" can only ever make this check
+            // false-green (a store rejecting for some unrelated reason still passes Phase 1), never
+            // false-red — consistent with Phase 1's own guarantee already being one-sided toward
+            // false-green, never false-red (see this function's own doc, above).
+            for (const [label, rec] of [
+                ['read', readRec],
+                ['delete', deleteRec],
+                ['deleteAllForRun', deleteAllRec],
+            ]) {
+                if (rec.outcome() === 'fulfilled') {
+                    throw new Error(`CS_OCCUPANCY violated (holder=${holder}): ${label}() completed successfully while ` +
+                        'the CS was still latched open — it must remain pending or reject with a typed ' +
+                        'lock-contention error until the latch releases.');
+                }
+            }
+            // Phase 2 (visibility): release the latch FIRST, then let everything settle.
+            latch.release();
+            await parkedP;
+            await Promise.allSettled([readP, deleteP, deleteAllP]);
+            const finalRead = await store.read(runId, stepId);
+            const fullBatch = holder === 'appendFenced' ? [...B1, ...B2] : B1;
+            const isFullBatch = eventsOf(finalRead).length === eventsOf(fullBatch).length &&
+                eventsOf(finalRead).every((v, i) => v === eventsOf(fullBatch)[i]);
+            const isEmpty = finalRead.length === 0;
+            if (!isFullBatch && !isEmpty) {
+                throw new Error(`CS_OCCUPANCY violated (holder=${holder}): expected exactly the full committed batch ` +
+                    `or exactly [] after release, got ${JSON.stringify(eventsOf(finalRead))} — a partial/` +
+                    'garbled result means the CS did not actually serialize these operations.');
+            }
+        },
+    };
+}
+/** The single-waiter subcase (issue #207, D3 §7): park a holder, start exactly ONE concurrent
+ *  `read()`, release — the read must show deterministic FULL-batch visibility (no "or []" arm,
+ *  since a read never destroys data — this is the case's whole point: with no concurrent
+ *  destroyer in the mix, visibility after release is unambiguous). */
+function buildCsOccupancySingleWaiterCase(adapter) {
+    return {
+        law: 'CS_OCCUPANCY',
+        name: 'single-waiter subcase: one concurrent read (no concurrent destroyer) sees deterministic full-batch visibility post-release',
+        run: async () => {
+            const { store } = adapter;
+            const { runId, stepId } = adapter.makeKey();
+            const B1 = [{ event: 'b1-e0' }];
+            await store.append(runId, stepId, B1);
+            const B2 = [{ event: 'b2-e0' }];
+            const { parkedP, latch } = await startLatchedHolder(store, 'appendFenced', runId, stepId, B2);
+            const readP = store.read(runId, stepId);
+            await drain(store);
+            latch.release();
+            await parkedP;
+            const result = await readP;
+            assertDeepEqualEvents(result, [...B1, ...B2], 'single-waiter subcase');
+        },
+    };
+}
+function buildPerKeyIndependenceCase(adapter) {
+    return {
+        law: 'PER_KEY_INDEPENDENCE',
+        name: 'a disjoint-run key completes a full append+read round-trip while another key is latched open (global-lock stores hang into the framework timeout — the intended red)',
+        run: async () => {
+            const { store } = adapter;
+            const { runId, stepId } = adapter.makeKey();
+            const other = adapter.makeKey();
+            const { parkedP, latch } = await startLatchedHolder(store, 'appendFenced', runId, stepId, [
+                { event: 'latched' },
+            ]);
+            await store.append(other.runId, other.stepId, [{ event: 'independent' }]);
+            const result = await store.read(other.runId, other.stepId);
+            assertDeepEqualEvents(result, [{ event: 'independent' }], 'PER_KEY_INDEPENDENCE');
+            latch.release();
+            await parkedP;
+        },
+    };
+}
+/**
+ * Builds the NO_SILENT_LOSS case (issue #207, D3 §7): a settle (read-then-delete) racing a
+ * still-parked `appendFenced` must adopt the full committed batch — never lose it silently.
+ *
+ * Scope note (issue #207 correction): this case only exercises the "settle wins the race, the
+ * guard is never asked to refuse" path. The complementary branch — the guard REFUSING because a
+ * settle already started (the `settledFlag` check inside this case's own guard) — is deliberately
+ * NOT separately re-asserted as its own top-level assertion here: it is absorbed by
+ * FENCE_REFUSES's own `appendFenced` refusal case above, which already asserts identical content
+ * (typed rejection, nothing written). Duplicating that assertion under this law's banner too would
+ * add no additional coverage.
+ *
+ * The one-sided fs caveat from `buildCsOccupancyCase`'s doc (above) applies here too: against a
+ * lock-skipping (rather than genuinely non-serializing) violator, false-green risk here is a
+ * loaded/slow-environment concern only, not a claim this case usually passes such a store.
+ */
+function buildNoSilentLossCase(adapter) {
+    return {
+        law: 'NO_SILENT_LOSS',
+        name: 'a settle (read-then-delete) starting while append is parked adopts the full committed batch — never silent loss',
+        run: async () => {
+            const { store } = adapter;
+            const { runId, stepId } = adapter.makeKey();
+            const B = [{ event: 'b0' }, { event: 'b1' }];
+            let settledFlag = false;
+            let releaseLatchFn;
+            const latch = new Promise((resolve) => {
+                releaseLatchFn = resolve;
+            });
+            let enteredResolveFn;
+            const entered = new Promise((resolve) => {
+                enteredResolveFn = resolve;
+            });
+            const guard = async () => {
+                enteredResolveFn();
+                if (settledFlag) {
+                    throw new WorkflowError('fenced-tck: refused (settled already)', {
+                        code: REFUSAL_CODE,
+                        category: 'STATE',
+                        agentAction: 'report_to_user',
+                        retryable: true,
+                    });
+                }
+                await latch;
+            };
+            const appendP = store.appendFenced(runId, stepId, B, guard);
+            // Detect (and safely ignore afterwards) a premature settlement — the conforming store must
+            // not settle appendP before its guard has been entered.
+            const prematureSettle = appendP.then(() => {
+                throw new Error('appendFenced settled (fulfilled) before entering its guard — NO_SILENT_LOSS setup invariant violated');
+            }, () => {
+                throw new Error('appendFenced settled (rejected) before entering its guard — NO_SILENT_LOSS setup invariant violated');
+            });
+            prematureSettle.catch(() => { }); // only used for the race below; its later settlement is expected
+            await Promise.race([entered, prematureSettle]);
+            settledFlag = true;
+            // Start (never await) the settle sequence.
+            const settleP = store
+                .read(runId, stepId)
+                .then((adopted) => store.delete(runId, stepId).then(() => adopted));
+            await drain(store);
+            releaseLatchFn();
+            const committed = await appendP;
+            if (committed.buffer_count !== B.length) {
+                throw new Error(`NO_SILENT_LOSS: expected appendFenced to commit all ${B.length} entries, got ` +
+                    `buffer_count=${committed.buffer_count}`);
+            }
+            const adopted = await settleP;
+            assertDeepEqualEvents(adopted, B, 'NO_SILENT_LOSS (an unlocked or CS-split settle yields [] with the append still committed)');
+            const finalRead = await store.read(runId, stepId);
+            if (finalRead.length !== 0) {
+                throw new Error(`NO_SILENT_LOSS: expected the buffer empty after the settle's delete, got ${finalRead.length} entries`);
+            }
+        },
+    };
+}
+/** A visible, non-silent documented-skip case for a law that a store's declared capabilities
+ *  don't reach — mirrors the `fenceForm: 'native-predicate'` skip precedent for the latch-based
+ *  trio laws. `reason` names exactly why (e.g. "store does not declare 'seal'"). */
+function skipCase(law, name, reason) {
+    return {
+        law,
+        name: `SKIPPED — ${reason}: ${name}`,
+        run: async () => {
+            // Intentional no-op — see the case name for why.
+        },
+    };
+}
+// ── CARRIAGE_ROUND_TRIP (issue #197 PR-1, the writer_nonce_carriage rung) ────────────────────────
+function buildCarriageRoundTripCases(adapter) {
+    const { store } = adapter;
+    if (!storeDeclaresNonceCarriage(store)) {
+        return [
+            skipCase('CARRIAGE_ROUND_TRIP', "nonce round-trip via options.writerNonce and read()'s _nonce", "store does not declare 'writer_nonce_carriage'"),
+        ];
+    }
+    return [
+        {
+            law: 'CARRIAGE_ROUND_TRIP',
+            name: 'a nonced append round-trips _nonce on read(); a bare append NEVER has _nonce fabricated',
+            run: async () => {
+                const { runId, stepId } = adapter.makeKey();
+                const NONCE = 'carriage-tck-nonce-1';
+                await store.append(runId, stepId, [{ event: 'nonced' }], { writerNonce: NONCE });
+                await store.append(runId, stepId, [{ event: 'bare' }]);
+                const entries = await store.read(runId, stepId);
+                const nonced = entries.find((e) => e.event === 'nonced');
+                const bare = entries.find((e) => e.event === 'bare');
+                if (nonced?._nonce !== NONCE) {
+                    throw new Error(`expected the nonced entry's _nonce to round-trip as '${NONCE}', got: ${nonced?._nonce}`);
+                }
+                if (bare !== undefined && Object.prototype.hasOwnProperty.call(bare, '_nonce')) {
+                    throw new Error(`expected the bare entry to have NO _nonce property at all (never fabricated), got: ${JSON.stringify(bare)}`);
+                }
+            },
+        },
+    ];
+}
+// ── SEAL + SEAL_BUDGET (issue #197 PR-1, the seal rung) ──────────────────────────────────────────
+function buildSealCases(adapter) {
+    const { store } = adapter;
+    if (!storeDeclaresSeal(store)) {
+        return [
+            skipCase('SEAL', 'sealFenced retires a live WAL to a sealed artifact', "store does not declare 'seal'"),
+            skipCase('SEAL_BUDGET', 'repeated seals up to SEALED_ARTIFACTS_LIMIT_PER_STEP, then capped', "store does not declare 'seal'"),
+        ];
+    }
+    const cases = [];
+    cases.push({
+        law: 'SEAL',
+        name: 'sealFenced on an absent key returns {sealed:false, reason:"absent"}; the guard still runs',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            let guardCalls = 0;
+            const result = await store.sealFenced(runId, stepId, async () => {
+                guardCalls++;
+            });
+            if (!(result.sealed === false && result.reason === 'absent')) {
+                throw new Error(`expected {sealed:false, reason:'absent'}, got: ${JSON.stringify(result)}`);
+            }
+            if (guardCalls < 1) {
+                throw new Error('expected the guard to run at least once even for an absent key');
+            }
+        },
+    });
+    cases.push({
+        law: 'SEAL',
+        name: 'sealFenced retires the live WAL: read() goes empty, listSealedForRun reports the same lines',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            await store.append(runId, stepId, [{ event: 'a1' }]);
+            await store.append(runId, stepId, [{ event: 'a2' }]);
+            const result = await store.sealFenced(runId, stepId, passingGuard());
+            if (result.sealed !== true) {
+                throw new Error(`expected {sealed:true}, got: ${JSON.stringify(result)}`);
+            }
+            const afterLive = await store.read(runId, stepId);
+            if (afterLive.length !== 0) {
+                throw new Error(`expected the live WAL empty after sealing, got ${afterLive.length} entries`);
+            }
+            const sealedArtifacts = await store.listSealedForRun(runId);
+            const thisKeyArtifacts = sealedArtifacts.filter((a) => a.step_id === stepId);
+            if (thisKeyArtifacts.length !== 1) {
+                throw new Error(`expected exactly 1 sealed artifact for this key, got ${thisKeyArtifacts.length}`);
+            }
+            const sealedEvents = thisKeyArtifacts[0].lines.flatMap((l) => l.entries.map((e) => e.event));
+            if (JSON.stringify(sealedEvents) !== JSON.stringify(['a1', 'a2'])) {
+                throw new Error(`expected sealed lines to preserve ['a1','a2'] in order, got ${JSON.stringify(sealedEvents)}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'SEAL',
+        name: 'a refusing guard rejects sealFenced — nothing is moved (live content survives, no new sealed artifact)',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            await store.append(runId, stepId, [{ event: 'a' }]);
+            const before = await store.listSealedForRun(runId);
+            let caught;
+            try {
+                await store.sealFenced(runId, stepId, refusingGuard());
+            }
+            catch (err) {
+                caught = err;
+            }
+            if (!(caught instanceof WorkflowError) || caught.code !== REFUSAL_CODE) {
+                throw new Error(`expected a typed WorkflowError(${REFUSAL_CODE}), got: ${caught}`);
+            }
+            const afterLive = await store.read(runId, stepId);
+            if (afterLive.length !== 1) {
+                throw new Error(`expected the live WAL untouched after a refused seal, got ${afterLive.length} entries`);
+            }
+            const after = await store.listSealedForRun(runId);
+            if (after.length !== before.length) {
+                throw new Error('expected no new sealed artifact after a refused seal');
+            }
+        },
+    });
+    cases.push({
+        law: 'SEAL',
+        name: 'deleteAllForRun retires sealed artifacts for the run too, not just the live WAL',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            await store.append(runId, stepId, [{ event: 'a' }]);
+            await store.sealFenced(runId, stepId, passingGuard());
+            const beforeCount = (await store.listSealedForRun(runId)).length;
+            if (beforeCount < 1) {
+                throw new Error('setup invariant violated: expected at least one sealed artifact before deleteAllForRun');
+            }
+            await store.deleteAllForRun(runId);
+            const after = await store.listSealedForRun(runId);
+            if (after.length !== 0) {
+                throw new Error(`expected deleteAllForRun to also remove sealed artifacts, got ${after.length} remaining`);
+            }
+        },
+    });
+    cases.push({
+        law: 'SEAL_BUDGET',
+        name: 'repeated seals of the same key succeed up to SEALED_ARTIFACTS_LIMIT_PER_STEP, then return {sealed:false, reason:"capped"} without evicting or losing data',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            for (let i = 0; i < SEALED_ARTIFACTS_LIMIT_PER_STEP; i++) {
+                await store.append(runId, stepId, [{ event: `e${i}` }]);
+                const result = await store.sealFenced(runId, stepId, passingGuard());
+                if (result.sealed !== true) {
+                    throw new Error(`expected seal #${i} to succeed, got: ${JSON.stringify(result)}`);
+                }
+            }
+            const atCap = (await store.listSealedForRun(runId)).filter((a) => a.step_id === stepId);
+            if (atCap.length !== SEALED_ARTIFACTS_LIMIT_PER_STEP) {
+                throw new Error(`expected exactly SEALED_ARTIFACTS_LIMIT_PER_STEP (${SEALED_ARTIFACTS_LIMIT_PER_STEP}) sealed artifacts, got ${atCap.length}`);
+            }
+            await store.append(runId, stepId, [{ event: 'one-too-many' }]);
+            const capped = await store.sealFenced(runId, stepId, passingGuard());
+            if (!(capped.sealed === false && capped.reason === 'capped')) {
+                throw new Error(`expected {sealed:false, reason:'capped'}, got: ${JSON.stringify(capped)}`);
+            }
+            // No silent eviction: still exactly the same N sealed artifacts, and the live content that
+            // failed to seal is still readable (the caller's fallback path — destructive drain — remains
+            // available; this law only asserts nothing was silently lost yet).
+            const stillAtCap = (await store.listSealedForRun(runId)).filter((a) => a.step_id === stepId);
+            if (stillAtCap.length !== SEALED_ARTIFACTS_LIMIT_PER_STEP) {
+                throw new Error(`expected the cap to hold at exactly ${SEALED_ARTIFACTS_LIMIT_PER_STEP} (no eviction), got ${stillAtCap.length}`);
+            }
+            const liveAfterCapped = await store.read(runId, stepId);
+            if (liveAfterCapped.length !== 1 || liveAfterCapped[0]?.event !== 'one-too-many') {
+                throw new Error('expected the un-sealable live content to remain readable (fallback-eligible), got: ' +
+                    JSON.stringify(liveAfterCapped));
+            }
+        },
+    });
+    return cases;
+}
+// ── PER_WRITER_BUDGET (issue #197 PR-1, design §5) ────────────────────────────────────────────────
+function buildPerWriterBudgetCases(adapter) {
+    const { store } = adapter;
+    const batch = (n, label) => Array.from({ length: n }, (_, i) => ({ event: `${label}-${i}` }));
+    const cases = [];
+    cases.push({
+        law: 'PER_WRITER_BUDGET',
+        name: "theft-fixed: one writer's near-full own partition does not steal another writer's independent budget on the SAME key",
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            const NEAR_LIMIT = BUFFER_LIMIT_COUNT - 1;
+            await store.append(runId, stepId, batch(NEAR_LIMIT, 'w1'), { writerNonce: 'w1' });
+            const r2 = await store.append(runId, stepId, batch(NEAR_LIMIT, 'w2'), { writerNonce: 'w2' });
+            // A "theft" bug (partitioning by whole-file instead of by writer) would see w1's NEAR_LIMIT
+            // already committed and refuse w2's own NEAR_LIMIT-sized append (combined > BUFFER_LIMIT_COUNT
+            // if mistakenly compared against the PER-WRITER ceiling) — a conforming store must not.
+            if (r2.buffer_count !== NEAR_LIMIT) {
+                throw new Error(`expected writer 'w2' to independently commit its own ${NEAR_LIMIT} entries regardless ` +
+                    `of writer 'w1's own near-full partition on the same key, got buffer_count=${r2.buffer_count}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'PER_WRITER_BUDGET',
+        name: 'the whole-file backstop binds across combined writers even when no single writer exceeds its own per-writer ceiling',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            const THIRD = Math.floor(BUFFER_BACKSTOP_COUNT / 3) + 10; // 3× exceeds the backstop; each alone is well under BUFFER_LIMIT_COUNT
+            await store.append(runId, stepId, batch(THIRD, 'a'), { writerNonce: 'a' });
+            await store.append(runId, stepId, batch(THIRD, 'b'), { writerNonce: 'b' });
+            let caught;
+            try {
+                await store.append(runId, stepId, batch(THIRD, 'c'), { writerNonce: 'c' });
+            }
+            catch (err) {
+                caught = err;
+            }
+            if (!(caught instanceof WorkflowError) || caught.code !== 'BUFFER_FULL') {
+                throw new Error(`expected a BUFFER_FULL WorkflowError once the combined file exceeds the backstop, got: ${caught}`);
+            }
+            const details = caught.details;
+            if (details.scope !== 'file') {
+                throw new Error(`expected details.scope === 'file' for a whole-file-backstop refusal, got: ${JSON.stringify(details)}`);
+            }
+        },
+    });
+    if (adapter.bytesOracle !== undefined) {
+        cases.push({
+            law: 'PER_WRITER_BUDGET',
+            name: "byte-exactness (adapter-supplied oracle): AppendResult's writer/file byte numbers match the oracle's own independent computation",
+            run: async () => {
+                const { runId, stepId } = adapter.makeKey();
+                const NONCE = 'byte-oracle-writer';
+                const result = await store.append(runId, stepId, [{ event: 'e1' }, { event: 'e2' }], {
+                    writerNonce: NONCE,
+                });
+                const oracle = await adapter.bytesOracle(runId, stepId, NONCE);
+                if (result.buffer_bytes !== oracle.bytes || result.buffer_count !== oracle.count) {
+                    throw new Error(`expected AppendResult writer-scope {count:${oracle.count}, bytes:${oracle.bytes}} per the ` +
+                        `oracle, got {count:${result.buffer_count}, bytes:${result.buffer_bytes}}`);
+                }
+            },
+        });
+    }
+    else {
+        cases.push(skipCase('PER_WRITER_BUDGET', 'byte-exactness against an adapter-supplied oracle', 'adapter did not supply bytesOracle (count-based assertions above still ran)'));
+    }
+    return cases;
+}
+// ── VERBATIM (issue #197 PR-1, the seal rung's byte-fidelity guarantee) ──────────────────────────
+function buildVerbatimCases(adapter) {
+    const { store } = adapter;
+    if (!storeDeclaresSeal(store)) {
+        return [
+            skipCase('VERBATIM', 'a seal moves bytes/shape without loss', "store does not declare 'seal'"),
+        ];
+    }
+    const cases = [];
+    // Shape-tolerant sibling — runs UNCONDITIONALLY for every seal-declaring store (in-memory has no
+    // on-disk representation at all, so only logical content/order can be asserted for it).
+    cases.push({
+        law: 'VERBATIM',
+        name: 'shape-tolerant: sealed content preserves every entry, in order, with no duplication or loss',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            const B = [{ event: 'v0' }, { event: 'v1' }, { event: 'v2' }];
+            await store.append(runId, stepId, B);
+            await store.sealFenced(runId, stepId, passingGuard());
+            const sealedArtifacts = (await store.listSealedForRun(runId)).filter((a) => a.step_id === stepId);
+            const events = sealedArtifacts.flatMap((a) => a.lines.flatMap((l) => l.entries.map((e) => e.event)));
+            if (JSON.stringify(events) !== JSON.stringify(['v0', 'v1', 'v2'])) {
+                throw new Error(`expected sealed content ['v0','v1','v2'] in order, got ${JSON.stringify(events)}`);
+            }
+        },
+    });
+    if (adapter.rawWalAccess !== undefined) {
+        cases.push({
+            law: 'VERBATIM',
+            name: 'fs-scoped: a seal moves the live WAL bytes to the sealed artifact byte-for-byte (no parse/re-copy)',
+            run: async () => {
+                const { runId, stepId } = adapter.makeKey();
+                await store.append(runId, stepId, [{ event: 'raw1' }, { event: 'raw2' }]);
+                const rawBefore = await adapter.rawWalAccess.readLiveRaw(runId, stepId);
+                if (rawBefore === undefined) {
+                    throw new Error('expected the live WAL to exist (raw bytes) before sealing');
+                }
+                const result = await store.sealFenced(runId, stepId, passingGuard());
+                if (result.sealed !== true) {
+                    throw new Error(`expected {sealed:true}, got: ${JSON.stringify(result)}`);
+                }
+                const rawAfter = await adapter.rawWalAccess.readSealedRaw(runId, stepId, 0);
+                if (rawAfter === undefined) {
+                    throw new Error('expected the sealed artifact to exist (raw bytes) at seq 0 after sealing');
+                }
+                if (rawAfter !== rawBefore) {
+                    throw new Error('expected the sealed artifact bytes to be byte-for-byte identical to the pre-seal live ' +
+                        `WAL bytes, got a difference (before=${JSON.stringify(rawBefore)}, after=${JSON.stringify(rawAfter)})`);
+                }
+            },
+        });
+    }
+    else {
+        cases.push(skipCase('VERBATIM', 'byte-for-byte raw comparison against an adapter-supplied rawWalAccess hook', 'adapter did not supply rawWalAccess (the shape-tolerant sibling case above still ran)'));
+    }
+    return cases;
+}
+/**
+ * Builds the contract cases for `adapter`. See each law's own doc above (the `build*Case`
+ * functions) for what it asserts. For `fenceForm: 'native-predicate'` adapters, `CS_OCCUPANCY`,
+ * `PER_KEY_INDEPENDENCE`, and `NO_SILENT_LOSS` are replaced with an explicit, VISIBLE
+ * documented-skip case each (never a silent omission) — see the adapter's own `fenceForm` doc.
+ */
+export function fencedTraceBufferContract(adapter) {
+    const cases = [];
+    const { store } = adapter;
+    // ── STRUCTURAL ──────────────────────────────────────────────────────────────────────────────
+    cases.push({
+        law: 'STRUCTURAL',
+        name: 'declaring any fenced method requires declaring all three',
+        run: async () => {
+            const s = store;
+            const has = {
+                appendFenced: typeof s.appendFenced === 'function',
+                deleteFenced: typeof s.deleteFenced === 'function',
+                deleteAllForRunFenced: typeof s.deleteAllForRunFenced === 'function',
+            };
+            const anyDeclared = has.appendFenced || has.deleteFenced || has.deleteAllForRunFenced;
+            const allDeclared = has.appendFenced && has.deleteFenced && has.deleteAllForRunFenced;
+            if (anyDeclared && !allDeclared) {
+                throw new Error(`store declares a SUBSET of the fenced trio (must be all-or-nothing): ${JSON.stringify(has)}`);
+            }
+        },
+    });
+    // issue #197 PR-1: the capability-ladder STRUCTURAL cases below. The first three exercise
+    // `validateTraceCapabilities` against hand-built STUB stores (never the real adapter store) —
+    // this is deliberately a MECHANISM test: PR-1 ships `validateTraceCapabilities` itself, but
+    // invoking it at real injection seams is PR-2's job, so there is no real call site yet whose
+    // behavior this could observe indirectly.
+    cases.push({
+        law: 'STRUCTURAL',
+        name: 'validateTraceCapabilities: declaring writer_nonce_carriage without seal methods throws TRACE_CAPABILITY_INCONSISTENT',
+        run: async () => {
+            const stub = minimalStubStore(new Set(['writer_nonce_carriage']));
+            const err = catchSync(() => validateTraceCapabilities(stub));
+            assertCapabilityInconsistent(err, 'writer_nonce_carriage');
+        },
+    });
+    cases.push({
+        law: 'STRUCTURAL',
+        name: 'validateTraceCapabilities: declaring seal without the fenced trio + sealFenced/listSealedForRun throws TRACE_CAPABILITY_INCONSISTENT',
+        run: async () => {
+            const stub = minimalStubStore(new Set(['seal'])); // no fenced trio, no sealFenced
+            const err = catchSync(() => validateTraceCapabilities(stub));
+            assertCapabilityInconsistent(err, 'seal');
+        },
+    });
+    cases.push({
+        law: 'STRUCTURAL',
+        name: 'validateTraceCapabilities: an undeclared store (no traceCapabilities at all) is a silent no-op — trio-alone stays legal',
+        run: async () => {
+            const stub = minimalStubStore(undefined);
+            const err = catchSync(() => validateTraceCapabilities(stub));
+            if (err !== undefined) {
+                throw new Error(`expected no throw for an undeclared store, got: ${err}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'STRUCTURAL',
+        name: "traceCapabilities is immutable: two reads of the REAL adapter store's declaration are content-identical",
+        run: async () => {
+            const first = store.traceCapabilities;
+            const second = store.traceCapabilities;
+            const firstArr = [...(first ?? [])].sort();
+            const secondArr = [...(second ?? [])].sort();
+            if (JSON.stringify(firstArr) !== JSON.stringify(secondArr)) {
+                throw new Error(`expected two reads of traceCapabilities to be content-identical, got ${JSON.stringify(firstArr)} then ${JSON.stringify(secondArr)}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'STRUCTURAL',
+        name: "the REAL adapter store's own declaration is internally consistent (ladder holds for what it actually declares)",
+        run: async () => {
+            const caps = store.traceCapabilities;
+            if (caps?.has('seal') === true && !storeDeclaresSeal(store)) {
+                throw new Error("adapter store declares 'seal' but storeDeclaresSeal(store) is false — declared but inconsistent");
+            }
+            if (caps?.has('writer_nonce_carriage') === true && !storeDeclaresNonceCarriage(store)) {
+                throw new Error("adapter store declares 'writer_nonce_carriage' but storeDeclaresNonceCarriage(store) is false — declared but inconsistent");
+            }
+        },
+    });
+    // ── FENCE_REFUSES ───────────────────────────────────────────────────────────────────────────
+    // Accepted limits of this law (issue #207 correction): FENCE_REFUSES asserts that a guard
+    // rejection propagates typed/unwrapped with nothing written/deleted — it does NOT, and cannot,
+    // distinguish that outcome from a store that (a) performs the write/delete, THEN discovers the
+    // guard should have refused, and rolls the effect back via a compensating action
+    // (write-then-rollback); or (b) a genuine crash between the effect and its own bookkeeping
+    // happens to leave residue that looks, from this law's own read-after observation, like
+    // "nothing written". Both are indistinguishable from a true refusal by this law's assertions —
+    // a store relying on either is simply out of this TCK's detection range, not certified free of
+    // that residue by a green run here.
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'appendFenced: guard rejection propagates typed with a populated reason category, nothing written',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            let caught;
+            try {
+                await store.appendFenced(runId, stepId, [{ event: 'e' }], refusingGuard());
+            }
+            catch (err) {
+                caught = err;
+            }
+            if (!(caught instanceof WorkflowError) || caught.code !== REFUSAL_CODE || !caught.category) {
+                throw new Error(`expected a typed WorkflowError(${REFUSAL_CODE}) with a populated category, got: ${caught}`);
+            }
+            const after = await store.read(runId, stepId);
+            if (after.length !== 0) {
+                throw new Error(`expected nothing written after a refused appendFenced, got ${after.length} entries`);
+            }
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'deleteFenced: guard rejection propagates typed with a populated reason category, nothing deleted',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            await store.append(runId, stepId, [{ event: 'seed' }]);
+            let caught;
+            try {
+                await store.deleteFenced(runId, stepId, refusingGuard());
+            }
+            catch (err) {
+                caught = err;
+            }
+            if (!(caught instanceof WorkflowError) || caught.code !== REFUSAL_CODE || !caught.category) {
+                throw new Error(`expected a typed WorkflowError(${REFUSAL_CODE}) with a populated category, got: ${caught}`);
+            }
+            const after = await store.read(runId, stepId);
+            if (after.length !== 1) {
+                throw new Error(`expected the seeded entry to survive a refused deleteFenced, got ${after.length}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'sequential two-call guard-caching kill: pass-guard append then refuse-guard append — second refuses, first entries intact',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            const r1 = await store.appendFenced(runId, stepId, [{ event: 'first' }], passingGuard());
+            if (r1.buffer_count !== 1) {
+                throw new Error(`expected the first append to commit 1 entry, got buffer_count=${r1.buffer_count}`);
+            }
+            let threw = false;
+            try {
+                await store.appendFenced(runId, stepId, [{ event: 'second' }], refusingGuard());
+            }
+            catch {
+                threw = true;
+            }
+            if (!threw) {
+                throw new Error('expected the second (refuse-guard) append to reject — guard-caching would make this incorrectly pass');
+            }
+            const after = await store.read(runId, stepId);
+            assertDeepEqualEvents(after, [{ event: 'first' }], 'sequential two-call guard-caching kill');
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'deleteAllForRunFenced: refusal with >=2 seeded files — ALL files intact, error propagates exactly as the guard threw it',
+        run: async () => {
+            const { runId } = adapter.makeKey();
+            const stepA = 'fenced-tck-step-a';
+            const stepB = 'fenced-tck-step-b';
+            await store.append(runId, stepA, [{ event: 'a' }]);
+            await store.append(runId, stepB, [{ event: 'b' }]);
+            let caught;
+            try {
+                await store.deleteAllForRunFenced(runId, refusingGuard());
+            }
+            catch (err) {
+                caught = err;
+            }
+            // issue #207 correction: assert the propagated error IS the guard's own typed error —
+            // never something a wrapping layer (e.g. toArtifactDeleteFailedError) substituted in its
+            // place (that would surface as ENGINE_ARTIFACT_DELETE_FAILED instead of REFUSAL_CODE).
+            if (!(caught instanceof WorkflowError) || caught.code !== REFUSAL_CODE) {
+                throw new Error(`expected deleteAllForRunFenced to reject with the guard's own typed error ` +
+                    `(WorkflowError, code=${REFUSAL_CODE}) — never wrapped — got: ${caught}`);
+            }
+            const a = await store.read(runId, stepA);
+            const b = await store.read(runId, stepB);
+            if (a.length !== 1 || b.length !== 1) {
+                throw new Error(`expected both seeded files intact after a refused sweep, got a=${a.length} b=${b.length}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'deleteAllForRunFenced: zero-match sweep still invokes the guard at least once, and its rejection propagates unwrapped',
+        run: async () => {
+            const { runId } = adapter.makeKey(); // never written — zero files match
+            let guardCalls = 0;
+            const countingRefusingGuard = async () => {
+                guardCalls++;
+                throw new WorkflowError('fenced-tck: guard refused (simulated)', {
+                    code: REFUSAL_CODE,
+                    category: 'STATE',
+                    agentAction: 'report_to_user',
+                    retryable: true,
+                });
+            };
+            let caught;
+            try {
+                await store.deleteAllForRunFenced(runId, countingRefusingGuard);
+            }
+            catch (err) {
+                caught = err;
+            }
+            // issue #207 correction: same exact-identity assertion as the >=2-file case above — a
+            // zero-match sweep is not a laxer case, it must reject with the guard's own typed error too.
+            if (!(caught instanceof WorkflowError) || caught.code !== REFUSAL_CODE) {
+                throw new Error(`expected a zero-match sweep with a refusing guard to reject with the guard's own typed ` +
+                    `error (WorkflowError, code=${REFUSAL_CODE}) — never wrapped — got: ${caught}`);
+            }
+            if (guardCalls < 1) {
+                throw new Error('expected the guard to be invoked at least once even for a zero-match sweep');
+            }
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: "deleteAllForRunFenced: a guard throwing FsIoError propagates it exactly — never mistaken for deleteIfExists's own failure and wrapped",
+        run: async () => {
+            // issue #207 correction, dedicated case (D3 §1's own demanded test): a realistic scenario
+            // is the guard's lock-free `runStore.get` itself hitting a filesystem error (e.g. EACCES on
+            // the run-record file) — since that surfaces as an FsIoError too, a sweep implementation
+            // that wraps "any FsIoError seen inside the per-file try" (rather than scoping the wrap to
+            // ONLY deleteIfExists's own failure) would incorrectly re-wrap the guard's own error as
+            // ENGINE_ARTIFACT_DELETE_FAILED, discarding its original identity.
+            const { runId } = adapter.makeKey();
+            const stepA = 'fenced-tck-step-fsio';
+            await store.append(runId, stepA, [{ event: 'seed' }]);
+            const cause = Object.assign(new Error('EACCES (simulated)'), { code: 'EACCES' });
+            const fsIoGuard = async () => {
+                throw new FsIoError('read', '/fenced-tck/simulated-guard-path', cause);
+            };
+            let caught;
+            try {
+                await store.deleteAllForRunFenced(runId, fsIoGuard);
+            }
+            catch (err) {
+                caught = err;
+            }
+            if (!(caught instanceof FsIoError)) {
+                throw new Error(`expected the guard's own FsIoError to propagate exactly (not wrapped as ` +
+                    `ENGINE_ARTIFACT_DELETE_FAILED via toArtifactDeleteFailedError), got: ${caught}`);
+            }
+            const after = await store.read(runId, stepA);
+            if (after.length !== 1) {
+                throw new Error(`expected the seeded file intact after a sweep refused by an FsIoError guard, got ${after.length}`);
+            }
+        },
+    });
+    cases.push({
+        law: 'FENCE_REFUSES',
+        name: 'COUNT_FIDELITY: deleteFenced with a pass-guard returns exactly the seeded entry count',
+        run: async () => {
+            const { runId, stepId } = adapter.makeKey();
+            const N = 5;
+            for (let i = 0; i < N; i++) {
+                await store.append(runId, stepId, [{ event: `e${i}` }]);
+            }
+            const count = await store.deleteFenced(runId, stepId, passingGuard());
+            if (count !== N) {
+                throw new Error(`expected deleteFenced to return exactly ${N}, got ${count}`);
+            }
+        },
+    });
+    // ── Latch-based laws: CS_OCCUPANCY, PER_KEY_INDEPENDENCE, NO_SILENT_LOSS ───────────────────
+    if (adapter.fenceForm === 'native-predicate') {
+        for (const law of ['CS_OCCUPANCY', 'PER_KEY_INDEPENDENCE', 'NO_SILENT_LOSS']) {
+            cases.push({
+                law,
+                name: `SKIPPED for native-predicate stores — TCK-green does NOT verify race closure; ` +
+                    "the store's own in-transaction fencing suite must (issue #207; the same posture " +
+                    "CLAIM_SINGLE_OWNER's own cross-host caveat states, issue #188). This case is an " +
+                    'explicit, visible documented-skip, not a silent omission.',
+                run: async () => {
+                    // Intentional no-op — see the case name for why.
+                },
+            });
+        }
+    }
+    else {
+        cases.push(buildCsOccupancyCase(adapter, 'appendFenced'));
+        cases.push(buildCsOccupancyCase(adapter, 'deleteFenced'));
+        cases.push(buildCsOccupancyCase(adapter, 'deleteAllForRunFenced'));
+        cases.push(buildCsOccupancySingleWaiterCase(adapter));
+        cases.push(buildPerKeyIndependenceCase(adapter));
+        cases.push(buildNoSilentLossCase(adapter));
+    }
+    // ── Capability-ladder laws (issue #197 PR-1): CARRIAGE_ROUND_TRIP, SEAL, SEAL_BUDGET,
+    // PER_WRITER_BUDGET, VERBATIM. Each produces a visible documented-skip (never a silent
+    // omission) for a store that doesn't declare the relevant rung — see each build*Cases
+    // function's own doc.
+    cases.push(...buildCarriageRoundTripCases(adapter));
+    cases.push(...buildSealCases(adapter));
+    cases.push(...buildPerWriterBudgetCases(adapter));
+    cases.push(...buildVerbatimCases(adapter));
+    return cases;
+}
+//# sourceMappingURL=fenced-trace-buffer-contract.js.map

package/dist/store/fenced-trace-buffer-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fenced-trace-buffer-contract.js","sourceRoot":"","sources":["../../src/store/fenced-trace-buffer-contract.ts"],"names":[],"mappings":"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"}

package/dist/store/in-memory-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../../src/store/in-memory-store.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,gBAAgB,CAAC;AAExB,4FAA4F;AAC5F,qBAAa,aAAc,YAAW,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgC;IACrD,sGAAsG;IACtG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IAEtD,iGAAiG;IACjG,QAAQ,CAAC,cAAc,QAAQ;IAE/B;wGACoG;IACpG,QAAQ,CAAC,wBAAwB,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAItE;IAEG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,GAAG,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IA4ChF,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAatC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IA6B7C,SAAS,CACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,kBAAkB,GAC7B,OAAO,CAAC,SAAS,CAAC;IAyDf,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CAOtD"}
+{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../../src/store/in-memory-store.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,gBAAgB,CAAC;AAExB,4FAA4F;AAC5F,qBAAa,aAAc,YAAW,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgC;IACrD,sGAAsG;IACtG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IAEtD,iGAAiG;IACjG,QAAQ,CAAC,cAAc,QAAQ;IAE/B;wGACoG;IACpG,QAAQ,CAAC,wBAAwB,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAItE;IAEG,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,GAAG,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IA4ChF,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAatC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IA6B7C,SAAS,CACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,kBAAkB,GAC7B,OAAO,CAAC,SAAS,CAAC;IAsDf,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CAOtD"}

package/dist/store/in-memory-store.js

@@ -1,5 +1,5 @@
 // InMemoryStore — in-memory implementation of RunStore for use in tests.
-import { WorkflowError, findEligibleSteps, deriveRunPhase, decideIdempotencyPolicy, computeClaimDeadline, } from '@sensigo/realm';
+import { WorkflowError, findEligibleSteps, deriveRunPhase, decideIdempotencyPolicy, computeClaimDeadline, isStepSettledOrInFlight, } from '@sensigo/realm';
 /** In-memory implementation of RunStore. Uses a Map keyed by run ID. No I/O, no locking. */
 export class InMemoryStore {
     runs = new Map();
@@ -106,6 +106,9 @@ export class InMemoryStore {
         // tick, during which a second `Promise.all`'d claimStep call's own (equally synchronous) read
         // can run BEFORE either call has written — verified empirically: two concurrent claimStep
         // calls for the same (runId, step) both resolved successfully before this fix.
+        // issue #207: `isStepSettledOrInFlight` (below) is pure/synchronous by design — it performs no
+        // I/O and awaits nothing, so calling it here does not reintroduce the microtask-yield point
+        // this fix removes; the no-await constraint above still holds.
         const run = this.runs.get(runId);
         if (run === undefined) {
             throw new WorkflowError(`Run '${runId}' not found`, {
@@ -115,13 +118,7 @@ export class InMemoryStore {
                 retryable: false,
             });
         }
-        const alreadyDone = [
-            ...run.completed_steps,
-            ...run.in_progress_steps,
-            ...run.failed_steps,
-            ...run.skipped_steps,
-        ];
-        if (alreadyDone.includes(stepName)) {
+        if (isStepSettledOrInFlight(run, stepName)) {
             throw new WorkflowError(`Step '${stepName}' is already claimed or done`, {
                 code: 'STATE_STEP_ALREADY_CLAIMED',
                 category: 'STATE',

package/dist/store/in-memory-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory-store.js","sourceRoot":"","sources":["../../src/store/in-memory-store.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,uBAAuB,EACvB,oBAAoB,GAMrB,MAAM,gBAAgB,CAAC;AAExB,4FAA4F;AAC5F,MAAM,OAAO,aAAa;IACP,IAAI,GAAG,IAAI,GAAG,EAAqB,CAAC;IACrD,sGAAsG;IACrF,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEtD,iGAAiG;IACxF,cAAc,GAAG,IAAI,CAAC;IAE/B;wGACoG;IAC3F,wBAAwB,GAA2C,IAAI,GAAG,CAAC;QAClF,mBAAmB;QACnB,4BAA4B;QAC5B,oBAAoB;KACrB,CAAC,CAAC;IAEH,KAAK,CAAC,MAAM,CAAC,OAAyB;QACpC,gFAAgF;QAChF,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACzC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC;YAC9D,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACzC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC3C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;oBAC3B,kFAAkF;oBAClF,sEAAsE;oBACtE,IAAI,uBAAuB,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,OAAO,EAAE,CAAC;wBAC3D,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;oBAC3C,CAAC;gBACH,CAAC;gBACD,wEAAwE;YAC1E,CAAC;QACH,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACrC,MAAM,MAAM,GAAc;YACxB,EAAE,EAAE,MAAM,CAAC,UAAU,EAAE;YACvB,WAAW,EAAE,OAAO,CAAC,UAAU;YAC/B,gBAAgB,EAAE,OAAO,CAAC,eAAe;YACzC,GAAG,CAAC,OAAO,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACpF,GAAG,CAAC,OAAO,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5F,eAAe,EAAE,EAAE;YACnB,iBAAiB,EAAE,EAAE;YACrB,YAAY,EAAE,EAAE;YAChB,aAAa,EAAE,EAAE;YACjB,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,CAAC;YACV,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,QAAQ,EAAE,EAAE;YACZ,UAAU,EAAE,GAAG;YACf,UAAU,EAAE,GAAG;YACf,cAAc,EAAE,KAAK;SACtB,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACjC,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACzC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,UAAU,KAAK,OAAO,CAAC,cAAc,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QACnF,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,KAAa;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,IAAI,aAAa,CAAC,QAAQ,KAAK,aAAa,EAAE;gBAClD,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,gBAAgB;gBAC7B,SAAS,EAAE,KAAK;aACjB,CAAC,CAAC;QACL,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAiB;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC1C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,aAAa,CAAC,QAAQ,MAAM,CAAC,EAAE,aAAa,EAAE;gBACtD,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,gBAAgB;gBAC7B,SAAS,EAAE,KAAK;aACjB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,QAAQ,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC;YACxC,MAAM,IAAI,aAAa,CAAC,wDAAwD,EAAE;gBAChF,IAAI,EAAE,yBAAyB;gBAC/B,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,gBAAgB;gBAC7B,SAAS,EAAE,IAAI;gBACf,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,EAAE;aAClF,CAAC,CAAC;QACL,CAAC;QACD,MAAM,OAAO,GAAc;YACzB,GAAG,MAAM;YACT,SAAS,EAAE,cAAc,CAAC,MAAM,CAAC;YACjC,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC;YAC3B,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACrC,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,SAAS,CACb,KAAa,EACb,QAAgB,EAChB,UAA8B;QAE9B,6FAA6F;QAC7F,6FAA6F;QAC7F,yFAAyF;QACzF,0FAA0F;QAC1F,2FAA2F;QAC3F,6FAA6F;QAC7F,8FAA8F;QAC9F,0FAA0F;QAC1F,+EAA+E;QAC/E,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,MAAM,IAAI,aAAa,CAAC,QAAQ,KAAK,aAAa,EAAE;gBAClD,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,gBAAgB;gBAC7B,SAAS,EAAE,KAAK;aACjB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,WAAW,GAAG;YAClB,GAAG,GAAG,CAAC,eAAe;YACtB,GAAG,GAAG,CAAC,iBAAiB;YACxB,GAAG,GAAG,CAAC,YAAY;YACnB,GAAG,GAAG,CAAC,aAAa;SACrB,CAAC;QACF,IAAI,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,aAAa,CAAC,SAAS,QAAQ,8BAA8B,EAAE;gBACvE,IAAI,EAAE,4BAA4B;gBAClC,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,sBAAsB;gBACnC,SAAS,EAAE,KAAK;aACjB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,aAAa,CAAC,SAAS,QAAQ,mBAAmB,EAAE;gBAC5D,IAAI,EAAE,yBAAyB;gBAC/B,QAAQ,EAAE,OAAO;gBACjB,WAAW,EAAE,sBAAsB;gBACnC,SAAS,EAAE,KAAK;aACjB,CAAC,CAAC;QACL,CAAC;QACD,2FAA2F;QAC3F,8FAA8F;QAC9F,MAAM,QAAQ,GAAG,oBAAoB,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;QACxE,MAAM,OAAO,GAAc;YACzB,GAAG,GAAG;YACN,iBAAiB,EAAE,CAAC,GAAG,GAAG,CAAC,iBAAiB,EAAE,QAAQ,CAAC;YACvD,MAAM,EAAE,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE;YACnD,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,GAAG,CAAC,OAAO,GAAG,CAAC;YACxB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACrC,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,UAAmB;QAC5B,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACpC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,UAAU,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF"}
+{"version":3,"file":"in-memory-store.js","sourceRoot":"","sources":["../../src/store/in-memory-store.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sensigo/realm-testing",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "publishConfig": {
     "access": "public"
   },
@@ -38,7 +38,7 @@
     "lint": "eslint src"
   },
   "dependencies": {
-    "@sensigo/realm": "^0.26.0",
+    "@sensigo/realm": "^0.28.0",
     "js-yaml": "^4.2.0"
   },
   "devDependencies": {