@rulvar/store-conformance 1.44.0 → 1.45.0

package/dist/index.d.ts

@@ -47,6 +47,9 @@ declare function leasableStoreConformance(mk: StoreFactory<LeasableStore>, optio
   ttlMs?: number;
 }): ConformanceSuite;
 //#endregion
+//#region src/fenced-writes.d.ts
+declare function fencedWritesConformance(mk: StoreFactory<LeasableStore>): ConformanceSuite;
+//#endregion
 //#region src/fixtures/golden-fold.d.ts
 /**
 * seq 0  agent spawn (running; abandoned by seq 6)
@@ -71,4 +74,4 @@ declare function foldStateSha256(entries: readonly JournalEntry[]): string;
 /** The reference hash; computed once from the kernel fold and frozen. */
 declare const GOLDEN_FOLD_STATE_SHA256 = "81e6ccff549fb3e6c1de4d34ba65b912162eba6f66403b5d5f23a3e1ec69243c";
 //#endregion
-export { type ConformanceCheck, type ConformanceSuite, GOLDEN_FOLD_JOURNAL, GOLDEN_FOLD_STATE_SHA256, type StoreFactory, type TestRegistrar, foldStateSha256, journalStoreConformance, leasableStoreConformance, makeSuite, materializeFoldState, registerConformance, stableStringify };
+export { type ConformanceCheck, type ConformanceSuite, GOLDEN_FOLD_JOURNAL, GOLDEN_FOLD_STATE_SHA256, type StoreFactory, type TestRegistrar, fencedWritesConformance, foldStateSha256, journalStoreConformance, leasableStoreConformance, makeSuite, materializeFoldState, registerConformance, stableStringify };

package/dist/index.js

@@ -219,7 +219,7 @@ const GOLDEN_FOLD_STATE_SHA256 = "81e6ccff549fb3e6c1de4d34ba65b912162eba6f66403b
 * (FakeAdapter call counters) live in the M2 cassette suite
 * (@rulvar/testing).
 */
-const RUN$1 = "conformance-run";
+const RUN$2 = "conformance-run";
 function baseEntry(seq, overrides) {
 	return {
 		hashVersion: 2,
@@ -238,7 +238,7 @@ function baseEntry(seq, overrides) {
 function sameEntry(a, b) {
 	return stableStringify(a) === stableStringify(b);
 }
-function meta(runId, overrides) {
+function meta$1(runId, overrides) {
 	return {
 		runId,
 		status: "running",
@@ -259,14 +259,14 @@ function journalStoreConformance(mk) {
 					blob: `${big}-${i}`,
 					sentinel: "END-OF-ENTRY"
 				} }));
-				const appends = submitted.map((item) => store.append(RUN$1, item));
-				const midLoads = [store.load(RUN$1), store.load(RUN$1)];
+				const appends = submitted.map((item) => store.append(RUN$2, item));
+				const midLoads = [store.load(RUN$2), store.load(RUN$2)];
 				await Promise.all([...appends, ...midLoads]);
 				for (const seen of await Promise.all(midLoads)) for (const item of seen) {
 					const original = submitted.find((candidate) => candidate.seq === item.seq);
 					ensure(original !== void 0 && sameEntry(item, original), "a1-append-atomicity", `a load observed a torn or foreign entry at seq ${item.seq}`);
 				}
-				const loaded = await store.load(RUN$1);
+				const loaded = await store.load(RUN$2);
 				ensure(loaded.length === submitted.length, "a1-append-atomicity", `expected ${submitted.length} whole entries, loaded ${loaded.length}`);
 				for (const item of loaded) {
 					const original = submitted.find((candidate) => candidate.seq === item.seq);
@@ -280,12 +280,12 @@ function journalStoreConformance(mk) {
 			async run() {
 				const store = await mk();
 				const entries = Array.from({ length: 10 }, (_, i) => baseEntry(i));
-				for (const item of entries) await store.append(RUN$1, item);
-				const first = await store.load(RUN$1);
+				for (const item of entries) await store.append(RUN$2, item);
+				const first = await store.load(RUN$2);
 				ensure(first.map((item) => item.seq).join(",") === entries.map((item) => item.seq).join(","), "a2-total-order", `sequential appends loaded out of order: ${first.map((item) => item.seq).join(",")}`);
-				await Promise.all(Array.from({ length: 8 }, (_, i) => store.append(RUN$1, baseEntry(10 + i))));
-				const second = await store.load(RUN$1);
-				const third = await store.load(RUN$1);
+				await Promise.all(Array.from({ length: 8 }, (_, i) => store.append(RUN$2, baseEntry(10 + i))));
+				const second = await store.load(RUN$2);
+				const third = await store.load(RUN$2);
 				ensure(second.map((item) => item.seq).join(",") === third.map((item) => item.seq).join(","), "a2-total-order", "two loads of the same run disagree on entry order");
 				ensure(second.length === 18 && new Set(second.map((item) => item.seq)).size === 18, "a2-total-order", "concurrent appends were lost or duplicated");
 				ensure(second.slice(0, 10).map((item) => item.seq).join(",") === entries.map((item) => item.seq).join(","), "a2-total-order", "later appends reordered the existing prefix");
@@ -298,8 +298,8 @@ function journalStoreConformance(mk) {
 				const store = await mk();
 				for (let i = 0; i < 5; i += 1) {
 					const item = baseEntry(i);
-					await store.append(RUN$1, item);
-					const loaded = await store.load(RUN$1);
+					await store.append(RUN$2, item);
+					const loaded = await store.load(RUN$2);
 					const last = loaded[loaded.length - 1];
 					ensure(loaded.length === i + 1 && last !== void 0 && sameEntry(last, item), "a3-read-your-writes", `append of seq ${i} was acknowledged but not visible to load`);
 				}
@@ -331,8 +331,8 @@ function journalStoreConformance(mk) {
 					spanId: "s",
 					startedAt: "2026-01-01T00:00:00.000Z"
 				};
-				await store.append(RUN$1, exotic);
-				const [loaded] = await store.load(RUN$1);
+				await store.append(RUN$2, exotic);
+				const [loaded] = await store.load(RUN$2);
 				ensure(loaded !== void 0 && sameEntry(loaded, exotic), "a4-opaque-payload", "the exotic entry did not round-trip byte-exactly (normalized, stripped, or rewritten)");
 				ensure(loaded.hashVersion === void 0, "a4-opaque-payload", "the store injected hashVersion into a legacy entry (normalization is read-side only)");
 			}
@@ -342,12 +342,12 @@ function journalStoreConformance(mk) {
 			title: "append rejects a duplicate or stale seq with the typed journal_order_violation",
 			async run() {
 				const store = await mk();
-				await store.append(RUN$1, baseEntry(0));
-				await store.append(RUN$1, baseEntry(1));
+				await store.append(RUN$2, baseEntry(0));
+				await store.append(RUN$2, baseEntry(1));
 				for (const stale of [1, 0]) {
 					let thrown;
 					try {
-						await store.append(RUN$1, baseEntry(stale, { value: {
+						await store.append(RUN$2, baseEntry(stale, { value: {
 							seq: stale,
 							second: true
 						} }));
@@ -356,9 +356,9 @@ function journalStoreConformance(mk) {
 					}
 					ensure(thrown?.code === "journal_order_violation", "a5-monotonic-seq", `append of stale seq ${stale} must reject with code 'journal_order_violation'`);
 				}
-				ensure((await store.load(RUN$1)).map((item) => item.seq).join(",") === "0,1", "a5-monotonic-seq", "a rejected stale append must never become visible");
-				await store.append(RUN$1, baseEntry(2));
-				ensure((await store.load(RUN$1)).length === 3, "a5-monotonic-seq", "the append of the true next seq must succeed after rejections");
+				ensure((await store.load(RUN$2)).map((item) => item.seq).join(",") === "0,1", "a5-monotonic-seq", "a rejected stale append must never become visible");
+				await store.append(RUN$2, baseEntry(2));
+				ensure((await store.load(RUN$2)).length === 3, "a5-monotonic-seq", "the append of the true next seq must succeed after rejections");
 			}
 		},
 		{
@@ -366,11 +366,11 @@ function journalStoreConformance(mk) {
 			title: "two writers appending the same next seq: exactly one persists, the loser is typed",
 			async run() {
 				const store = await mk();
-				for (let i = 0; i < 3; i += 1) await store.append(RUN$1, baseEntry(i));
-				const settled = await Promise.allSettled([store.append(RUN$1, baseEntry(3, { value: {
+				for (let i = 0; i < 3; i += 1) await store.append(RUN$2, baseEntry(i));
+				const settled = await Promise.allSettled([store.append(RUN$2, baseEntry(3, { value: {
 					seq: 3,
 					writer: "a"
-				} })), store.append(RUN$1, baseEntry(3, { value: {
+				} })), store.append(RUN$2, baseEntry(3, { value: {
 					seq: 3,
 					writer: "b"
 				} }))]);
@@ -378,7 +378,7 @@ function journalStoreConformance(mk) {
 				const rejected = settled.filter((item) => item.status === "rejected");
 				ensure(fulfilled.length === 1 && rejected.length === 1, "a5-stale-tail-race", `exactly one of two same-seq appends may persist (got ${fulfilled.length} fulfilled)`);
 				ensure((rejected[0]?.reason)?.code === "journal_order_violation", "a5-stale-tail-race", "the losing writer must observe the typed 'journal_order_violation' conflict");
-				const loaded = await store.load(RUN$1);
+				const loaded = await store.load(RUN$2);
 				ensure(loaded.length === 4 && loaded.filter((item) => item.seq === 3).length === 1, "a5-stale-tail-race", "the journal must hold exactly one entry at the raced seq");
 				const seqs = loaded.map((item) => item.seq);
 				ensure(seqs.every((seq, index) => index === 0 || seq > (seqs[index - 1] ?? NaN)), "a5-stale-tail-race", "reloading after the race must show a strictly increasing total order");
@@ -390,7 +390,7 @@ function journalStoreConformance(mk) {
 			async run() {
 				const store = await mk();
 				const seed = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store
 				});
 				for (let i = 0; i < 3; i += 1) await seed.appendSinglePhase({
@@ -401,14 +401,14 @@ function journalStoreConformance(mk) {
 					spanId: "conf-span",
 					value: { i }
 				});
-				const tail = await store.load(RUN$1);
+				const tail = await store.load(RUN$2);
 				const writerA = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store,
 					priorEntries: tail
 				});
 				const writerB = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store,
 					priorEntries: tail
 				});
@@ -430,7 +430,7 @@ function journalStoreConformance(mk) {
 				const rejected = settled.filter((item) => item.status === "rejected");
 				ensure(settled.filter((item) => item.status === "fulfilled").length === 1 && rejected.length === 1, "a5-stale-replayer-fencing", "exactly one stale-tail replayer append may persist");
 				ensure((rejected[0]?.reason)?.code === "journal_order_violation", "a5-stale-replayer-fencing", "the losing replayer must observe the typed 'journal_order_violation' conflict");
-				const seqs = (await store.load(RUN$1)).map((item) => item.seq);
+				const seqs = (await store.load(RUN$2)).map((item) => item.seq);
 				ensure(new Set(seqs).size === seqs.length && seqs.every((seq, index) => index === 0 || seq > (seqs[index - 1] ?? NaN)), "a5-stale-replayer-fencing", "reopening the store must show a unique, strictly increasing seq order");
 			}
 		},
@@ -440,28 +440,28 @@ function journalStoreConformance(mk) {
 			async run() {
 				const store = await mk();
 				ensure((await store.load("never-written")).length === 0, "meta-separation", "load of an unknown run must return an empty journal");
-				await store.append(RUN$1, baseEntry(0));
-				await store.putMeta(meta(RUN$1, {
+				await store.append(RUN$2, baseEntry(0));
+				await store.putMeta(meta$1(RUN$2, {
 					name: "wf-a",
 					tags: ["team:core"]
 				}));
-				await store.putMeta(meta("other-run", {
+				await store.putMeta(meta$1("other-run", {
 					status: "suspended",
 					name: "wf-b"
 				}));
-				ensure((await store.listRuns()).filter((candidate) => candidate.runId === RUN$1).length === 1, "meta-separation", "putMeta must upsert one record per run");
-				await store.putMeta(meta(RUN$1, {
+				ensure((await store.listRuns()).filter((candidate) => candidate.runId === RUN$2).length === 1, "meta-separation", "putMeta must upsert one record per run");
+				await store.putMeta(meta$1(RUN$2, {
 					status: "suspended",
 					name: "wf-a",
 					tags: ["team:core"]
 				}));
 				const suspended = await store.listRuns({ status: "suspended" });
-				ensure(suspended.some((candidate) => candidate.runId === RUN$1) && suspended.every((candidate) => candidate.status === "suspended"), "meta-separation", "listRuns must reflect the replaced meta and honor the status filter");
+				ensure(suspended.some((candidate) => candidate.runId === RUN$2) && suspended.every((candidate) => candidate.status === "suspended"), "meta-separation", "listRuns must reflect the replaced meta and honor the status filter");
 				const byName = await store.listRuns({ name: "wf-b" });
 				ensure(byName.length === 1 && byName[0]?.runId === "other-run", "meta-separation", "listRuns must honor the name filter");
 				const byTag = await store.listRuns({ tags: ["team:core"] });
-				ensure(byTag.length === 1 && byTag[0]?.runId === RUN$1, "meta-separation", "listRuns must honor the tags filter");
-				await store.putMeta(meta(RUN$1, {
+				ensure(byTag.length === 1 && byTag[0]?.runId === RUN$2, "meta-separation", "listRuns must honor the tags filter");
+				await store.putMeta(meta$1(RUN$2, {
 					status: "suspended",
 					name: "wf-a",
 					tags: ["team:core"],
@@ -471,20 +471,20 @@ function journalStoreConformance(mk) {
 					argsHash: "a".repeat(64),
 					genesis: "g".repeat(26)
 				}));
-				const roundTripped = (await store.listRuns()).find((candidate) => candidate.runId === RUN$1);
+				const roundTripped = (await store.listRuns()).find((candidate) => candidate.runId === RUN$2);
 				ensure(roundTripped?.budgetUsd === 12.5, "meta-separation", "putMeta/listRuns must round-trip optional RunMeta fields (budgetUsd)");
 				ensure(roundTripped?.segments === 3, "meta-separation", "putMeta/listRuns must round-trip optional RunMeta fields (segments)");
 				ensure(roundTripped?.argsProvided === true && roundTripped.argsHash === "a".repeat(64), "meta-separation", "putMeta/listRuns must round-trip optional RunMeta fields (argsProvided, argsHash)");
 				ensure(roundTripped?.genesis === "g".repeat(26), "meta-separation", "putMeta/listRuns must round-trip optional RunMeta fields (genesis)");
-				ensure((await store.listRuns({ statuses: ["suspended", "running"] })).some((candidate) => candidate.runId === RUN$1), "meta-separation", "listRuns({ statuses }) must include every meta whose status matches (supersets are allowed, drops are not)");
+				ensure((await store.listRuns({ statuses: ["suspended", "running"] })).some((candidate) => candidate.runId === RUN$2), "meta-separation", "listRuns({ statuses }) must include every meta whose status matches (supersets are allowed, drops are not)");
 				const lookup = store.getMeta;
 				if (typeof lookup === "function") {
-					const fetched = await lookup.call(store, RUN$1);
-					ensure(fetched?.runId === RUN$1 && fetched.genesis === "g".repeat(26), "meta-separation", "getMeta must return the stored meta for an existing run");
+					const fetched = await lookup.call(store, RUN$2);
+					ensure(fetched?.runId === RUN$2 && fetched.genesis === "g".repeat(26), "meta-separation", "getMeta must return the stored meta for an existing run");
 					ensure(await lookup.call(store, "conformance-missing-run") === void 0, "meta-separation", "getMeta must resolve undefined for a missing run, never reject");
 				}
-				await store.delete(RUN$1);
-				ensure((await store.load(RUN$1)).length === 0 && !(await store.listRuns()).some((candidate) => candidate.runId === RUN$1), "meta-separation", "delete must remove the journal and the meta record");
+				await store.delete(RUN$2);
+				ensure((await store.load(RUN$2)).length === 0 && !(await store.listRuns()).some((candidate) => candidate.runId === RUN$2), "meta-separation", "delete must remove the journal and the meta record");
 			}
 		},
 		{
@@ -492,8 +492,8 @@ function journalStoreConformance(mk) {
 			title: "the kernel fold over the stored golden journal hashes to the reference",
 			async run() {
 				const store = await mk();
-				for (const item of GOLDEN_FOLD_JOURNAL) await store.append(RUN$1, item);
-				const hash = foldStateSha256(await store.load(RUN$1));
+				for (const item of GOLDEN_FOLD_JOURNAL) await store.append(RUN$2, item);
+				const hash = foldStateSha256(await store.load(RUN$2));
 				ensure(hash === GOLDEN_FOLD_STATE_SHA256, "golden-fold-state", `fold state hash ${hash} differs from the reference ${GOLDEN_FOLD_STATE_SHA256}: the store influenced replay semantics`);
 			}
 		},
@@ -503,7 +503,7 @@ function journalStoreConformance(mk) {
 			async run() {
 				const store = await mk();
 				const writer = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store
 				});
 				const suspended = await writer.appendSuspended({
@@ -525,17 +525,17 @@ function journalStoreConformance(mk) {
 				})]);
 				const outcomes = [first, second];
 				ensure(outcomes.filter((outcome) => outcome.applied).length === 1, "decide-once-oracle", "a race of two resolution attempts must settle exactly one applied");
-				const journaled = await store.load(RUN$1);
+				const journaled = await store.load(RUN$2);
 				ensure(journaled.filter((item) => item.kind === "resolution").length === 2, "decide-once-oracle", "both attempts must be journaled (the loser is a journaled noop)");
 				const state = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store,
 					priorEntries: journaled,
 					strict: true
 				}).suspensionState(suspended.seq);
 				const winnerSeq = outcomes.find((outcome) => outcome.applied)?.seq;
 				ensure(state.state === "resolved" && state.by === winnerSeq, "decide-once-oracle", "the replayed fold disagrees with the live winner");
-				const reload = await store.load(RUN$1);
+				const reload = await store.load(RUN$2);
 				ensure(foldStateSha256(journaled) === foldStateSha256(reload), "decide-once-oracle", "two loads of the raced journal fold to different states");
 			}
 		},
@@ -545,7 +545,7 @@ function journalStoreConformance(mk) {
 			async run() {
 				const store = await mk();
 				const writer = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store
 				});
 				const branchIdentity = {
@@ -581,9 +581,9 @@ function journalStoreConformance(mk) {
 					reason: "conformance abandon"
 				})).applied, "abandon-derived-skip", "the covering abandon must apply");
 				const replayed = new Replayer({
-					runId: RUN$1,
+					runId: RUN$2,
 					store,
-					priorEntries: await store.load(RUN$1),
+					priorEntries: await store.load(RUN$2),
 					strict: true
 				});
 				replayed.setDisposition(dispositionHook(replayed.fold.abandonFold, buildDeriverRegistry()));
@@ -613,7 +613,7 @@ function journalStoreConformance(mk) {
 * ships in M5 (@rulvar/store-sqlite); the multi-process soak re-runs
 * these sections under real concurrency in M8.
 */
-const RUN = "lease-run";
+const RUN$1 = "lease-run";
 function leaseEntry(seq) {
 	return {
 		hashVersion: 2,
@@ -645,11 +645,11 @@ function leasableStoreConformance(mk, options) {
 			title: "acquire on a held lease rejects with the typed LeaseHeldError",
 			async run() {
 				const store = await mk();
-				const held = await store.acquire(RUN, "owner-a");
-				ensure(held.runId === RUN && held.owner === "owner-a" && typeof held.epoch === "number", "lease-exclusive-acquire", "acquire must return a Lease with runId, owner, and a numeric fencing epoch");
-				ensure(await mustReject(() => store.acquire(RUN, "owner-b")) instanceof LeaseHeldError, "lease-exclusive-acquire", "a second acquire while held must reject with LeaseHeldError (typed, code lease_held)");
+				const held = await store.acquire(RUN$1, "owner-a");
+				ensure(held.runId === RUN$1 && held.owner === "owner-a" && typeof held.epoch === "number", "lease-exclusive-acquire", "acquire must return a Lease with runId, owner, and a numeric fencing epoch");
+				ensure(await mustReject(() => store.acquire(RUN$1, "owner-b")) instanceof LeaseHeldError, "lease-exclusive-acquire", "a second acquire while held must reject with LeaseHeldError (typed, code lease_held)");
 				await store.release(held);
-				ensure((await store.acquire(RUN, "owner-b")).owner === "owner-b", "lease-exclusive-acquire", "after release, acquire must succeed for a new owner");
+				ensure((await store.acquire(RUN$1, "owner-b")).owner === "owner-b", "lease-exclusive-acquire", "after release, acquire must succeed for a new owner");
 			}
 		},
 		{
@@ -657,14 +657,14 @@ function leasableStoreConformance(mk, options) {
 			title: "the epoch is monotonic; a stale-epoch append is rejected and invisible",
 			async run() {
 				const store = await mk();
-				const first = await store.acquire(RUN, "owner-a");
-				await store.append(RUN, leaseEntry(0), first);
+				const first = await store.acquire(RUN$1, "owner-a");
+				await store.append(RUN$1, leaseEntry(0), first);
 				await store.release(first);
-				const second = await store.acquire(RUN, "owner-b");
+				const second = await store.acquire(RUN$1, "owner-b");
 				ensure(second.epoch > first.epoch, "fencing-stale-epoch", `the fencing epoch must be monotonic per run (got ${second.epoch} after ${first.epoch})`);
-				await store.append(RUN, leaseEntry(1), second);
-				ensure(await mustReject(() => store.append(RUN, leaseEntry(2), first)) !== void 0, "fencing-stale-epoch", "an append carrying a stale epoch must be rejected");
-				const loaded = await store.load(RUN);
+				await store.append(RUN$1, leaseEntry(1), second);
+				ensure(await mustReject(() => store.append(RUN$1, leaseEntry(2), first)) !== void 0, "fencing-stale-epoch", "an append carrying a stale epoch must be rejected");
+				const loaded = await store.load(RUN$1);
 				ensure(loaded.length === 2 && !loaded.some((item) => item.seq === 2), "fencing-stale-epoch", "a rejected stale-epoch append must never appear in load");
 			}
 		},
@@ -673,12 +673,12 @@ function leasableStoreConformance(mk, options) {
 			title: "a released lease can neither renew nor append",
 			async run() {
 				const store = await mk();
-				const lease = await store.acquire(RUN, "owner-a");
+				const lease = await store.acquire(RUN$1, "owner-a");
 				await store.renew(lease);
 				await store.release(lease);
 				ensure(await mustReject(() => store.renew(lease)) !== void 0, "lease-release-fences", "renew of a released lease must reject");
-				ensure(await mustReject(() => store.append(RUN, leaseEntry(0), lease)) !== void 0, "lease-release-fences", "append under a released lease must reject");
-				ensure((await store.load(RUN)).length === 0, "lease-release-fences", "nothing may be visible after only-rejected appends");
+				ensure(await mustReject(() => store.append(RUN$1, leaseEntry(0), lease)) !== void 0, "lease-release-fences", "append under a released lease must reject");
+				ensure((await store.load(RUN$1)).length === 0, "lease-release-fences", "nothing may be visible after only-rejected appends");
 			}
 		}
 	];
@@ -688,13 +688,13 @@ function leasableStoreConformance(mk, options) {
 		title: "renew at ttl/3 keeps the lease held past ttl; an unrenewed lease expires",
 		async run() {
 			const store = await mk();
-			const held = await store.acquire(RUN, "owner-a");
+			const held = await store.acquire(RUN$1, "owner-a");
 			const cadence = Math.floor(ttlMs / 3);
 			const deadline = Date.now() + Math.ceil(ttlMs * 1.5);
 			while (Date.now() < deadline) {
 				await sleep(cadence);
 				await store.renew(held);
-				ensure(await mustReject(() => store.acquire(RUN, "owner-b")) instanceof LeaseHeldError, "lease-ttl-and-renew-cadence", "a lease renewed at ttl/3 must stay held past the original ttl");
+				ensure(await mustReject(() => store.acquire(RUN$1, "owner-b")) instanceof LeaseHeldError, "lease-ttl-and-renew-cadence", "a lease renewed at ttl/3 must stay held past the original ttl");
 			}
 			await store.release(held);
 			const abandoned = await store.acquire("expiring-run", "owner-a");
@@ -705,4 +705,130 @@ function leasableStoreConformance(mk, options) {
 	return makeSuite("leasableStoreConformance", checks);
 }
 //#endregion
-export { GOLDEN_FOLD_JOURNAL, GOLDEN_FOLD_STATE_SHA256, foldStateSha256, journalStoreConformance, leasableStoreConformance, makeSuite, materializeFoldState, registerConformance, stableStringify };
+//#region src/fenced-writes.ts
+/**
+* fencedWritesConformance (the fenced run state RFC, phase 2): the
+* executable definition of the `fencedWrites` capability. Run it ONLY
+* against stores that declare the marker; the checks are the promise
+* the marker makes:
+* - a mutation carrying a stale or released lease (putMeta, delete,
+*   append) rejects with the typed LeaseHeldError and mutates NOTHING;
+* - a mutation guarded by a live lease for a DIFFERENT run rejects the
+*   same way (a lease fences exactly the run it names);
+* - a mutation carrying no lease keeps single-writer semantics.
+*
+* Staleness is produced with release+reacquire (the epoch is monotonic
+* per the leasable contract), so the suite needs no wall-clock sleeps.
+*/
+const RUN = "fenced-run";
+const OTHER = "fenced-other-run";
+function fencedEntry(seq) {
+	return {
+		hashVersion: 2,
+		seq,
+		scope: "",
+		key: `fenced-key-${seq}`,
+		ordinal: 0,
+		kind: "step",
+		status: "ok",
+		value: { seq },
+		spanId: "fenced-span",
+		startedAt: (/* @__PURE__ */ new Date(17e11 + seq * 1e3)).toISOString()
+	};
+}
+function meta(runId, status, segments) {
+	return {
+		runId,
+		status,
+		segments,
+		updatedAt: `at-${status}-${String(segments)}`
+	};
+}
+async function readMeta(store, runId) {
+	const lookup = store;
+	if (typeof lookup.getMeta === "function") return lookup.getMeta(runId);
+	return (await store.listRuns()).find((m) => m.runId === runId);
+}
+async function mustRejectFenced(checkId, what, operation) {
+	try {
+		await operation();
+	} catch (thrown) {
+		ensure(thrown instanceof LeaseHeldError, checkId, `${what} must reject with the typed LeaseHeldError, got ${String(thrown)}`);
+		return;
+	}
+	ensure(false, checkId, `${what} must reject`);
+}
+function fencedWritesConformance(mk) {
+	return makeSuite("fencedWritesConformance", [
+		{
+			id: "fenced-marker-declared",
+			title: "the store declares the fencedWrites promise",
+			async run() {
+				ensure((await mk()).fencedWrites === true, "fenced-marker-declared", "fencedWritesConformance targets stores declaring `fencedWrites: true`; the marker is a promise, not an inference");
+			}
+		},
+		{
+			id: "fenced-meta-stale-rejected",
+			title: "a stale putMeta rejects typed and the successor meta is intact",
+			async run() {
+				const store = await mk();
+				const first = await store.acquire(RUN, "owner-a");
+				await store.putMeta(meta(RUN, "running", 2), first);
+				await store.release(first);
+				const second = await store.acquire(RUN, "owner-b");
+				await store.putMeta(meta(RUN, "running", 3), second);
+				await mustRejectFenced("fenced-meta-stale-rejected", "a stale putMeta", () => store.putMeta(meta(RUN, "cancelled", 2), first));
+				const current = await readMeta(store, RUN);
+				ensure(current !== void 0 && current.status === "running" && current.segments === 3, "fenced-meta-stale-rejected", `the successor meta (status running, segments 3) must survive a stale putMeta unchanged, got ${JSON.stringify(current)}`);
+			}
+		},
+		{
+			id: "fenced-delete-stale-rejected",
+			title: "a stale delete rejects typed and journal plus meta are intact",
+			async run() {
+				const store = await mk();
+				const first = await store.acquire(RUN, "owner-a");
+				await store.append(RUN, fencedEntry(0), first);
+				await store.putMeta(meta(RUN, "running", 1), first);
+				await store.release(first);
+				const second = await store.acquire(RUN, "owner-b");
+				await mustRejectFenced("fenced-delete-stale-rejected", "a stale delete", () => store.delete(RUN, first));
+				ensure((await store.load(RUN)).length === 1, "fenced-delete-stale-rejected", "the journal must survive a stale delete unchanged");
+				ensure(await readMeta(store, RUN) !== void 0, "fenced-delete-stale-rejected", "the meta row must survive a stale delete unchanged");
+				await store.delete(RUN, second);
+				ensure((await store.load(RUN)).length === 0 && await readMeta(store, RUN) === void 0, "fenced-delete-stale-rejected", "a delete under the current lease must remove the journal and the meta row");
+			}
+		},
+		{
+			id: "fenced-run-match",
+			title: "a live lease for a different run guards nothing",
+			async run() {
+				const store = await mk();
+				const foreign = await store.acquire(OTHER, "owner-a");
+				await store.putMeta(meta(RUN, "running", 1));
+				await store.append(RUN, fencedEntry(0));
+				await mustRejectFenced("fenced-run-match", "a cross-run putMeta", () => store.putMeta(meta(RUN, "cancelled", 1), foreign));
+				await mustRejectFenced("fenced-run-match", "a cross-run append", () => store.append(RUN, fencedEntry(1), foreign));
+				await mustRejectFenced("fenced-run-match", "a cross-run delete", () => store.delete(RUN, foreign));
+				const current = await readMeta(store, RUN);
+				ensure(current !== void 0 && current.status === "running", "fenced-run-match", "the run guarded by nobody must survive every cross-run mutation attempt");
+				ensure((await store.load(RUN)).length === 1, "fenced-run-match", "a cross-run append must never become visible");
+			}
+		},
+		{
+			id: "fenced-unleased-passthrough",
+			title: "mutations carrying no lease keep single-writer semantics",
+			async run() {
+				const store = await mk();
+				await store.putMeta(meta(RUN, "running", 1));
+				await store.append(RUN, fencedEntry(0));
+				const current = await readMeta(store, RUN);
+				ensure(current !== void 0 && current.status === "running", "fenced-unleased-passthrough", "an unleased putMeta must keep working");
+				await store.delete(RUN);
+				ensure((await store.load(RUN)).length === 0 && await readMeta(store, RUN) === void 0, "fenced-unleased-passthrough", "an unleased delete must keep working");
+			}
+		}
+	]);
+}
+//#endregion
+export { GOLDEN_FOLD_JOURNAL, GOLDEN_FOLD_STATE_SHA256, fencedWritesConformance, foldStateSha256, journalStoreConformance, leasableStoreConformance, makeSuite, materializeFoldState, registerConformance, stableStringify };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/store-conformance",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "description": "Rulvar executable store conformance kit (DEF-4).",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,7 +22,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/core": "1.44.0"
+    "@rulvar/core": "1.45.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",