@usagekit/store 0.1.0

package/dist/conformance/capabilities.js

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "vitest";
+import { input, ref, command, budget, quantity } from "./helpers.js";
+export function capabilityTests(factory, caps) {
+    describe("capability guarantees", () => {
+        const durable = caps.durable ? test : test.skip;
+        durable("requires durable", async () => {
+            const f = await factory();
+            try {
+                const r = await f.store.reserve(input());
+                if (r.outcome !== "reserved")
+                    throw new Error("fixture");
+                const g = await f.store.markDispatchIntent({
+                    ...command(r.operation),
+                    holder: "process1",
+                    leaseTtlMs: 1000,
+                });
+                expect(g).toMatchObject({ granted: true });
+                if (!f.restart)
+                    throw new Error("durable factory requires restart");
+                const restarted = await f.restart();
+                f.clock.advance(1000);
+                const op = await restarted.getOperation(ref(r.operation));
+                expect(op?.state).toBe("dispatch_intended");
+                const recovery = await restarted.claimForRecovery({
+                    ...ref(r.operation),
+                    holder: "process2",
+                    leaseTtlMs: 1000,
+                });
+                expect(recovery).toMatchObject({ claimed: true });
+                expect(await restarted.markDispatchIntent({
+                    ...command(op),
+                    holder: "process2",
+                    leaseTtlMs: 1000,
+                })).toMatchObject({ granted: false });
+            }
+            finally {
+                await f.close();
+            }
+        });
+        const rolling = caps.rollingWindows ? test : test.skip;
+        rolling("requires rollingWindows", async () => {
+            const f = await factory();
+            try {
+                f.budgets.push(budget({ limit: quantity(1n), window: { kind: "rolling", days: 1 } }));
+                expect(await f.store.reserve(input())).toMatchObject({ outcome: "reserved" });
+                f.clock.advance(86400000 - 1);
+                expect(await f.store.reserve(input())).toMatchObject({ outcome: "exceeded" });
+                f.clock.advance(1);
+                expect(await f.store.reserve(input())).toMatchObject({ outcome: "reserved" });
+            }
+            finally {
+                await f.close();
+            }
+        });
+        test("quantity precision obeys advertised capability", async () => {
+            const f = await factory();
+            try {
+                expect(await f.store.reserve(input({ estimate: [quantity(1n, "units", caps.maxQuantityScale)] }))).toMatchObject({ outcome: "reserved" });
+                await expect(f.store.reserve(input({ estimate: [quantity(1n, "units", caps.maxQuantityScale + 1)] }))).rejects.toThrow("InvalidInput");
+            }
+            finally {
+                await f.close();
+            }
+        });
+    });
+}

package/dist/conformance/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { StoreFactory } from "./factory.js";
+export declare function dispatchTests(factory: StoreFactory): void;

package/dist/conformance/dispatch.js

@@ -0,0 +1,80 @@
+import { beforeEach, afterEach, describe, expect, test } from "vitest";
+import { input, command, ref } from "./helpers.js";
+export function dispatchTests(factory) {
+    describe("dispatch and leases", () => {
+        let f;
+        beforeEach(async () => {
+            f = await factory();
+        });
+        afterEach(async () => f.close());
+        const reserved = async () => {
+            const r = await f.store.reserve(input());
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            return r.operation;
+        };
+        test("first intent, identical and different replay never grant again", async () => {
+            const op = await reserved();
+            const cmd = { ...command(op), holder: "h1", leaseTtlMs: 1000 };
+            const grant = await f.store.markDispatchIntent(cmd);
+            expect(grant).toMatchObject({
+                granted: true,
+                operation: { state: "dispatch_intended", version: 2 },
+                lease: { holder: "h1", expiresAt: "2026-09-23T12:00:01.000Z" },
+            });
+            for (const commandId of [cmd.commandId, crypto.randomUUID()])
+                expect(await f.store.markDispatchIntent({ ...cmd, commandId })).toMatchObject({
+                    granted: false,
+                    reason: "already_dispatched",
+                });
+        });
+        test("two concurrent intents grant once", async () => {
+            const op = await reserved();
+            const results = await Promise.all(["a", "b"].map((holder) => f.store.markDispatchIntent({ ...command(op), holder, leaseTtlMs: 1000 })));
+            expect(results.filter((r) => "granted" in r && r.granted)).toHaveLength(1);
+        });
+        test("version conflict leaves state unchanged; unknown operation is representable", async () => {
+            const op = await reserved();
+            expect(await f.store.markDispatchIntent({
+                ...command(op),
+                expectedVersion: 0,
+                holder: "h",
+                leaseTtlMs: 1,
+            })).toMatchObject({ granted: false, reason: "version_conflict" });
+            expect(await f.store.getOperation(ref(op))).toEqual(op);
+            expect(await f.store.markDispatchIntent({
+                ...command(op),
+                operationId: "missing",
+                holder: "h",
+                leaseTtlMs: 1,
+            })).toEqual({ granted: false, reason: "not_reserved", operation: null });
+        });
+        test("renewal retains version/id; foreign, expired and missing fail", async () => {
+            const op = await reserved();
+            const g = await f.store.markDispatchIntent({ ...command(op), holder: "h", leaseTtlMs: 1000 });
+            if (!("granted" in g) || !g.granted)
+                throw new Error("fixture");
+            const renew = { ...ref(op), leaseId: g.lease.leaseId, leaseTtlMs: 2000 };
+            f.clock.advance(500);
+            expect(await f.store.renewLease(renew)).toMatchObject({
+                renewed: true,
+                lease: { leaseId: g.lease.leaseId, expiresAt: "2026-09-23T12:00:02.500Z" },
+            });
+            expect((await f.store.getOperation(ref(op)))?.version).toBe(2);
+            expect(await f.store.renewLease({ ...renew, leaseId: "foreign" })).toEqual({
+                renewed: false,
+                reason: "not_holder",
+            });
+            f.clock.advance(2000);
+            expect(await f.store.renewLease(renew)).toEqual({ renewed: false, reason: "expired" });
+            expect(await f.store.getOperation(ref(op))).toMatchObject({
+                state: "dispatch_intended",
+                lease: { leaseId: g.lease.leaseId },
+            });
+            expect(await f.store.renewLease({ ...renew, operationId: "missing" })).toEqual({
+                renewed: false,
+                reason: "not_active",
+            });
+        });
+    });
+}

package/dist/conformance/expiration.d.ts

@@ -0,0 +1,2 @@
+import type { StoreFactory } from "./factory.js";
+export declare function expirationTests(factory: StoreFactory): void;

package/dist/conformance/expiration.js

@@ -0,0 +1,131 @@
+import { beforeEach, afterEach, describe, test, expect } from "vitest";
+import { input, budget, quantity, ref, command } from "./helpers.js";
+export function expirationTests(factory) {
+    describe("undispatched reservation expiry", () => {
+        let f;
+        beforeEach(async () => {
+            f = await factory();
+        });
+        afterEach(async () => f.close());
+        test("finite default deadline is snapshotted; replay cannot extend it", async () => {
+            const i = input(), r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            expect(r.operation.reservationExpiresAt).toBe(new Date(f.clock.now().getTime() + 300000).toISOString());
+            f.clock.advance(1000);
+            expect(await f.store.reserve(i)).toEqual({ ...r, replayed: true });
+        });
+        test("process loss before intent releases headroom on the next reserve", async () => {
+            f.budgets.push(budget({ limit: quantity(1n) }));
+            const i = input({ reservationTtlMs: 1000 });
+            await f.store.reserve(i);
+            f.clock.advance(1000);
+            expect(await f.store.reserve(input())).toMatchObject({ outcome: "reserved" });
+            expect(await f.store.getOperation(ref(i))).toMatchObject({ state: "released", version: 2 });
+            expect(await f.store.reserve(i)).toMatchObject({
+                replayed: true,
+                operation: { state: "released" },
+            });
+        });
+        test("expiry fences intent, sweeps are bounded and repeatable", async () => {
+            const i = input({ reservationTtlMs: 1 }), r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            await f.store.reserve(input({ reservationTtlMs: 1 }));
+            await f.store.reserve(input({ reservationTtlMs: 1 }));
+            f.clock.advance(1);
+            expect(await f.store.markDispatchIntent({
+                ...command(r.operation),
+                holder: "h",
+                leaseTtlMs: 1000,
+            })).toMatchObject({
+                granted: false,
+                reason: "reservation_expired",
+                operation: { state: "released", version: 2 },
+            });
+            expect(await f.store.expireReservations({ namespace: "test", limit: 1 })).toEqual({
+                outcome: "expired",
+                count: 1,
+                hasMore: true,
+            });
+            expect(await f.store.expireReservations({ namespace: "test", limit: 1 })).toEqual({
+                outcome: "expired",
+                count: 1,
+                hasMore: false,
+            });
+            expect(await f.store.expireReservations({ namespace: "test" })).toEqual({
+                outcome: "expired",
+                count: 0,
+                hasMore: false,
+            });
+        });
+        test("dispatch intent is never released by reservation expiry, even after its lease expires", async () => {
+            f.budgets.push(budget({ limit: quantity(1n) }));
+            const i = input({ reservationTtlMs: 1 }), r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            expect(await f.store.markDispatchIntent({ ...command(r.operation), holder: "h", leaseTtlMs: 10 })).toMatchObject({ granted: true });
+            f.clock.advance(11);
+            expect(await f.store.expireReservations({ namespace: "test" })).toMatchObject({ count: 0 });
+            expect(await f.store.reserve(input())).toMatchObject({ outcome: "exceeded" });
+            expect(await f.store.claimForRecovery({ ...ref(i), holder: "recovery", leaseTtlMs: 1000 })).toMatchObject({ claimed: true });
+        });
+        test("concurrent sweeps release once and keep other namespaces isolated", async () => {
+            const i = input({ reservationTtlMs: 1 });
+            await f.store.reserve(i);
+            const other = {
+                ...input({ reservationTtlMs: 1 }),
+                scope: { ...i.scope, namespace: "other" },
+            };
+            await f.store.reserve(other);
+            f.clock.advance(1);
+            const results = await Promise.all([
+                f.store.expireReservations({ namespace: "test" }),
+                f.store.expireReservations({ namespace: "test" }),
+            ]);
+            expect(results.map((r) => ("count" in r ? r.count : -1)).sort()).toEqual([0, 1]);
+            expect(await f.store.getOperation(ref(other))).toMatchObject({ state: "reserved" });
+        });
+        test("admission sweeps at most one default batch of expired reservations", async () => {
+            for (let n = 0; n < 105; n++)
+                await f.store.reserve(input({ operationId: `expired-${n}`, reservationTtlMs: 1 }));
+            f.clock.advance(1);
+            await f.store.reserve(input());
+            expect(await f.store.expireReservations({ namespace: "test" })).toEqual({
+                outcome: "expired",
+                count: 5,
+                hasMore: false,
+            });
+        });
+        test("expired intent releases its own hold atomically without sweeping another operation", async () => {
+            f.budgets.push(budget({ limit: quantity(2n) }));
+            const i = input({ reservationTtlMs: 1 }), r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            const other = input({ reservationTtlMs: 1 });
+            await f.store.reserve(other);
+            f.clock.advance(1);
+            expect(await f.store.markDispatchIntent({
+                ...command(r.operation),
+                holder: "h",
+                leaseTtlMs: 1000,
+            })).toMatchObject({
+                granted: false,
+                reason: "reservation_expired",
+                operation: { state: "released", version: 2 },
+            });
+            expect(await f.store.getOperation(ref(other))).toMatchObject({ state: "reserved" });
+            expect(await f.store.applicableBudgets({
+                scope: i.scope,
+                surface: i.surface,
+                units: ["requests"],
+            })).toMatchObject([{ reserved: quantity(1n), remaining: quantity(1n) }]);
+        });
+        test("invalid lifetimes and batch sizes are rejected", async () => {
+            for (const ttl of [0, -1, 86400001, 1.5])
+                await expect(f.store.reserve(input({ reservationTtlMs: ttl }))).rejects.toThrow("InvalidInput");
+            for (const limit of [0, 1001])
+                await expect(f.store.expireReservations({ namespace: "test", limit })).rejects.toThrow("InvalidInput");
+        });
+    });
+}

package/dist/conformance/factory.d.ts

@@ -0,0 +1,17 @@
+import type { Budget } from "@usagekit/core";
+import type { Store, ManualClock } from "../index.js";
+export type StoreCapabilities = {
+    durable: boolean;
+    rollingWindows: boolean;
+    maxMoneyUnits: bigint;
+    maxQuantityScale: number;
+};
+export type StoreFixture = {
+    store: Store;
+    clock: ManualClock;
+    budgets: Budget[];
+    close(): Promise<void>;
+    /** Persistent adapters must terminate and reopen their backing process here. */
+    restart?: () => Promise<Store>;
+};
+export type StoreFactory = () => Promise<StoreFixture>;

package/dist/conformance/factory.js

@@ -0,0 +1 @@
+export {};

package/dist/conformance/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { ReserveInput, Operation, Receipt, Budget, Quantity } from "@usagekit/core";
+export declare const quantity: (value?: bigint, unit?: string, scale?: number) => Quantity;
+export declare const input: (overrides?: Partial<ReserveInput>) => ReserveInput;
+export declare const ref: (op: ReserveInput) => {
+    namespace: string;
+    principal: string;
+    operationId: string;
+};
+export declare const command: (op: Operation) => {
+    commandId: `${string}-${string}-${string}-${string}-${string}`;
+    expectedVersion: number;
+    namespace: string;
+    principal: string;
+    operationId: string;
+};
+export declare const receipt: (overrides?: Partial<Receipt>) => Receipt;
+export declare const budget: (overrides?: Partial<Budget>) => Budget;
+export declare const unknownReceipt: () => Receipt;

package/dist/conformance/helpers.js

@@ -0,0 +1,49 @@
+export const quantity = (value = 1n, unit = "requests", scale = 0) => ({
+    value,
+    unit,
+    scale,
+});
+export const input = (overrides = {}) => ({
+    operationId: crypto.randomUUID(),
+    scope: { namespace: "test", principal: "u1", connection: "c1" },
+    fundingSource: "byok",
+    costOwner: "u1",
+    surface: "app",
+    source: "app",
+    provider: "search",
+    operation: "search",
+    estimate: [quantity()],
+    ...overrides,
+});
+export const ref = (op) => ({
+    namespace: op.scope.namespace,
+    principal: op.scope.principal,
+    operationId: op.operationId,
+});
+export const command = (op) => ({
+    ...ref(op),
+    commandId: crypto.randomUUID(),
+    expectedVersion: op.version,
+});
+export const receipt = (overrides = {}) => ({
+    id: crypto.randomUUID(),
+    measurements: [{ unit: "requests", quantity: quantity(), certainty: "measured" }],
+    cost: { certainty: "measured", money: { units: 1n, currency: "USD" } },
+    occurredAt: "2026-09-23T12:00:00.000Z",
+    recordedAt: "2026-09-23T12:00:00.000Z",
+    cached: false,
+    failed: false,
+    ...overrides,
+});
+export const budget = (overrides = {}) => ({
+    id: crypto.randomUUID(),
+    version: 1,
+    scope: { kind: "principal", namespace: "test", principal: "u1" },
+    surface: "any",
+    unit: "requests",
+    limit: quantity(2n),
+    window: { kind: "calendar_month", timezone: "UTC" },
+    onExceed: "block",
+    ...overrides,
+});
+export const unknownReceipt = () => receipt({ cost: { certainty: "unknown", money: null } });

package/dist/conformance/index.d.ts

@@ -0,0 +1,4 @@
+export { runStoreConformance } from "./suite.js";
+export type { StoreFactory, StoreCapabilities } from "./factory.js";
+export { runStoreScalingConformance } from "./scaling.js";
+export type { ScalingFixture } from "./scaling.js";

package/dist/conformance/index.js

@@ -0,0 +1,2 @@
+export { runStoreConformance } from "./suite.js";
+export { runStoreScalingConformance } from "./scaling.js";

package/dist/conformance/properties.d.ts

@@ -0,0 +1,2 @@
+import type { StoreFactory } from "./factory.js";
+export declare function propertyTests(factory: StoreFactory): void;

package/dist/conformance/properties.js

@@ -0,0 +1,220 @@
+import { describe, expect, test } from "vitest";
+import fc from "fast-check";
+import { input, command, ref, receipt, unknownReceipt, budget, quantity } from "./helpers.js";
+const numRuns = globalThis.process?.env?.CI === "true" ? 1000 : 200;
+export function propertyTests(factory) {
+    describe("generated command interleavings", () => {
+        test("holders never reacquire dispatch and mutations preserve state invariants", async () => {
+            await fc.assert(fc.asyncProperty(fc.integer({ min: 2, max: 5 }), fc.array(fc.record({
+                kind: fc.constantFrom("intent", "renew", "settle", "correct", "release", "claim", "advanceClock"),
+                holder: fc.nat(4),
+                advance: fc.integer({ min: 1, max: 1500 }),
+                stale: fc.boolean(),
+                unknown: fc.boolean(),
+            }), { minLength: 1, maxLength: 70 }), async (k, sequence) => {
+                const f = await factory();
+                try {
+                    const i = input({ reservationTtlMs: 1000 }), r = await f.store.reserve(i);
+                    if (r.outcome !== "reserved")
+                        throw new Error("fixture");
+                    let grants = 0;
+                    const leases = [];
+                    for (const step of sequence) {
+                        const before = (await f.store.getOperation(ref(i)));
+                        const cmd = {
+                            ...command(before),
+                            expectedVersion: step.stale ? 0 : before.version,
+                        };
+                        let result;
+                        const leaseId = step.stale
+                            ? (leases[0] ?? "foreign")
+                            : (before.lease?.leaseId ?? "foreign");
+                        const authority = {
+                            kind: (before.lease?.holder.startsWith("recovery") ? "recovery" : "lease"),
+                            leaseId,
+                        };
+                        if (step.kind === "advanceClock")
+                            f.clock.advance(step.advance);
+                        if (step.kind === "intent") {
+                            result = await f.store.markDispatchIntent({
+                                ...cmd,
+                                holder: `h${step.holder % k}`,
+                                leaseTtlMs: 1000,
+                            });
+                            if (result &&
+                                typeof result === "object" &&
+                                "granted" in result &&
+                                result.granted) {
+                                grants++;
+                                leases.push(result.lease.leaseId);
+                            }
+                        }
+                        if (step.kind === "renew")
+                            result = await f.store.renewLease({ ...ref(i), leaseId, leaseTtlMs: 1000 });
+                        if (step.kind === "claim") {
+                            result = await f.store.claimForRecovery({
+                                ...ref(i),
+                                holder: `recovery${step.holder % k}`,
+                                leaseTtlMs: 1000,
+                            });
+                            if (result && typeof result === "object" && "claimed" in result && result.claimed)
+                                leases.push(result.lease.leaseId);
+                        }
+                        if (step.kind === "settle") {
+                            const c = {
+                                ...cmd,
+                                authority,
+                                receipt: step.unknown ? unknownReceipt() : receipt(),
+                            };
+                            const settled = await f.store.settle(c);
+                            result = settled;
+                            if (settled.outcome === "settled")
+                                expect(await f.store.settle(c)).toEqual({ ...settled, replayed: true });
+                        }
+                        if (step.kind === "correct") {
+                            const c = {
+                                ...cmd,
+                                authority: before.state === "settled"
+                                    ? { kind: "late_evidence", source: "provider" }
+                                    : authority,
+                                receipt: receipt(),
+                                replacesReceiptId: before.receipts.at(-1)?.id ?? "missing",
+                                reason: "adjust",
+                            };
+                            const corrected = await f.store.correct(c);
+                            result = corrected;
+                            if (corrected.outcome === "settled")
+                                expect(await f.store.correct(c)).toEqual({ ...corrected, replayed: true });
+                        }
+                        if (step.kind === "release") {
+                            const c = { ...cmd, reason: "cancel" };
+                            const released = await f.store.releaseUndispatched(c);
+                            result = released;
+                            if (released.outcome === "released")
+                                expect(await f.store.releaseUndispatched(c)).toEqual({
+                                    ...released,
+                                    replayed: true,
+                                });
+                        }
+                        const after = (await f.store.getOperation(ref(i)));
+                        const mutated = result &&
+                            typeof result === "object" &&
+                            (("reason" in result && result.reason === "reservation_expired") ||
+                                ("granted" in result && result.granted) ||
+                                ("claimed" in result && result.claimed) ||
+                                ("outcome" in result &&
+                                    ["settled", "released"].includes(String(result.outcome))));
+                        expect(grants).toBeLessThanOrEqual(1);
+                        expect(after.version).toBe(before.version + (mutated ? 1 : 0));
+                        expect(after.receipts.length).toBeGreaterThanOrEqual(before.receipts.length);
+                        const allowed = {
+                            reserved: ["reserved", "dispatch_intended", "released"],
+                            dispatch_intended: ["dispatch_intended", "pending", "settled"],
+                            pending: ["pending", "settled"],
+                            settled: ["settled"],
+                            released: ["released"],
+                        };
+                        expect(allowed[before.state]).toContain(after.state);
+                        const live = leases.filter((id) => id === after.lease?.leaseId &&
+                            Date.parse(after.lease.expiresAt) > f.clock.now().getTime());
+                        expect(new Set(live).size).toBeLessThanOrEqual(1);
+                    }
+                }
+                finally {
+                    await f.close();
+                }
+            }), { numRuns, verbose: 2 });
+        });
+        test("many operations never over-admit any blocking budget", async () => {
+            await fc.assert(fc.asyncProperty(fc.array(fc.record({
+                kind: fc.constantFrom("principal", "connection", "platform_pool"),
+                limit: fc.integer({ min: 0, max: 30 }),
+                warn: fc.boolean(),
+            }), { minLength: 1, maxLength: 4 }), fc.array(fc.record({
+                owner: fc.integer({ min: 1, max: 3 }),
+                amount: fc.integer({ min: 0, max: 5 }),
+                settled: fc.boolean(),
+            }), { minLength: 1, maxLength: 30 }), async (bounds, operations) => {
+                const f = await factory();
+                try {
+                    for (const spec of bounds)
+                        f.budgets.push(budget({
+                            scope: spec.kind === "principal"
+                                ? { kind: "principal", namespace: "test", principal: "u1" }
+                                : spec.kind === "connection"
+                                    ? { kind: "connection", namespace: "test", connection: "c1" }
+                                    : { kind: "platform_pool", namespace: "test", poolId: "pool" },
+                            limit: quantity(BigInt(spec.limit)),
+                            onExceed: spec.warn ? "warn" : "block",
+                        }));
+                    const accepted = [];
+                    for (const spec of operations) {
+                        const i = input({
+                            scope: { namespace: "test", principal: `u${spec.owner}`, connection: "c1" },
+                            platformPools: ["pool"],
+                            estimate: [quantity(BigInt(spec.amount))],
+                        });
+                        const r = await f.store.reserve(i);
+                        if (r.outcome === "reserved") {
+                            accepted.push(r.operation);
+                            if (spec.settled) {
+                                const g = await f.store.markDispatchIntent({
+                                    ...command(r.operation),
+                                    holder: "h",
+                                    leaseTtlMs: 1000,
+                                });
+                                if (!("granted" in g) || !g.granted)
+                                    throw new Error("fixture");
+                                await f.store.settle({
+                                    ...command(g.operation),
+                                    authority: { kind: "lease", leaseId: g.lease.leaseId },
+                                    receipt: receipt({
+                                        measurements: [
+                                            {
+                                                unit: "requests",
+                                                certainty: "measured",
+                                                quantity: quantity(BigInt(spec.amount)),
+                                            },
+                                        ],
+                                    }),
+                                });
+                            }
+                        }
+                        for (const b of f.budgets.filter((b) => b.onExceed === "block")) {
+                            const total = accepted
+                                .filter((op) => op.budgetEpochs.some((e) => e.budgetId === b.id))
+                                .reduce((n, op) => n + op.estimate[0].value, 0n);
+                            expect(total).toBeLessThanOrEqual(b.limit.value);
+                        }
+                    }
+                }
+                finally {
+                    await f.close();
+                }
+            }), { numRuns, verbose: 2 });
+        });
+        test("accepted reserve and release replay without state mutation", async () => {
+            await fc.assert(fc.asyncProperty(fc.bigInt({ min: 0n, max: 100000n }), fc.boolean(), async (amount, release) => {
+                const f = await factory();
+                try {
+                    const i = input({ estimate: [quantity(amount)] });
+                    const r = await f.store.reserve(i);
+                    if (r.outcome !== "reserved")
+                        throw new Error("fixture");
+                    expect(await f.store.reserve(i)).toEqual({ ...r, replayed: true });
+                    if (release) {
+                        const c = { ...command(r.operation), reason: "cancel" };
+                        const result = await f.store.releaseUndispatched(c);
+                        expect(await f.store.releaseUndispatched(c)).toEqual({ ...result, replayed: true });
+                    }
+                    const before = await f.store.getOperation(ref(i));
+                    await f.store.reserve(i);
+                    expect(await f.store.getOperation(ref(i))).toEqual(before);
+                }
+                finally {
+                    await f.close();
+                }
+            }), { numRuns, verbose: 2 });
+        });
+    });
+}

package/dist/conformance/reads.d.ts

@@ -0,0 +1,2 @@
+import type { StoreFactory, StoreCapabilities } from "./factory.js";
+export declare function readsTests(factory: StoreFactory, capabilities: StoreCapabilities): void;