@usagekit/store 0.1.0

package/dist/conformance/reads.js

@@ -0,0 +1,181 @@
+import { beforeEach, afterEach, describe, test, expect } from "vitest";
+import { input, command, receipt, unknownReceipt, budget, quantity, ref } from "./helpers.js";
+export function readsTests(factory, capabilities) {
+    describe("reads and exact bounds", () => {
+        let f;
+        beforeEach(async () => {
+            f = await factory();
+        });
+        afterEach(async () => f.close());
+        const query = (overrides = {}) => ({
+            scope: { kind: "namespace", namespace: "test" },
+            from: "2026-09-01T00:00:00.000Z",
+            to: "2026-10-01T00:00:00.000Z",
+            units: ["requests"],
+            groupBy: ["provider"],
+            ...overrides,
+        });
+        const settled = async (r = receipt(), principal = "u1", provider = "search") => {
+            const result = await f.store.reserve(input({
+                scope: {
+                    namespace: "test",
+                    principal,
+                    connection: "c1",
+                    group: "g1",
+                    accessCredential: { kind: "api_key", id: "k1" },
+                },
+                platformPools: ["p1"],
+                provider,
+            }));
+            if (result.outcome !== "reserved")
+                throw new Error("fixture");
+            const g = await f.store.markDispatchIntent({
+                ...command(result.operation),
+                holder: "h",
+                leaseTtlMs: 1000,
+            });
+            if (!("granted" in g) || !g.granted)
+                throw new Error("fixture");
+            return f.store.settle({
+                ...command(g.operation),
+                authority: { kind: "lease", leaseId: g.lease.leaseId },
+                receipt: r,
+            });
+        };
+        test.each([
+            "principal",
+            "provider",
+            "operation",
+            "surface",
+            "source",
+            "connection",
+            "day",
+            "access_credential",
+            "platform_pool",
+        ])("group by %s uses only requested dimensions", async (dim) => {
+            await settled();
+            const page = await f.store.aggregate(query({ groupBy: [dim] }));
+            expect(page.rows).toHaveLength(1);
+            expect(Object.keys(page.rows[0].dimensions)).toEqual([dim]);
+            expect(page.rows[0].measurements[0].quantity?.value).toBe(1n);
+        });
+        test("late receipt groups by occurrence; corrected history is not double-counted", async () => {
+            const r = receipt({ occurredAt: "2026-09-02T10:00:00.000Z" });
+            const op = await settled(r);
+            if (op.outcome !== "settled")
+                throw new Error("fixture");
+            await f.store.correct({
+                ...command(op.operation),
+                authority: { kind: "late_evidence", source: "provider" },
+                receipt: receipt({
+                    occurredAt: r.occurredAt,
+                    cost: { certainty: "measured", money: { units: 2n, currency: "USD" } },
+                }),
+                replacesReceiptId: r.id,
+                reason: "fix",
+            });
+            const page = await f.store.aggregate(query({ groupBy: ["day"] }));
+            expect(page.rows[0]).toMatchObject({
+                dimensions: { day: "2026-09-02" },
+                cost: { money: { units: 2n } },
+            });
+        });
+        test("certainty precedence and pending count", async () => {
+            await settled();
+            await settled(receipt({ cost: { certainty: "estimated", money: { units: 2n, currency: "USD" } } }));
+            expect((await f.store.aggregate(query())).rows[0]?.cost).toEqual({
+                certainty: "estimated",
+                money: { units: 3n, currency: "USD" },
+            });
+            await settled(unknownReceipt());
+            expect((await f.store.aggregate(query())).rows[0]).toMatchObject({
+                cost: { certainty: "unknown", money: null },
+                unknownOperations: 1n,
+            });
+        });
+        test("cursor chain is a frozen version snapshot and bound to its query", async () => {
+            await settled(receipt(), "u1", "a");
+            await settled(receipt(), "u1", "b");
+            const first = await f.store.aggregate(query({ limit: 1 }));
+            expect(first.nextCursor).toBeTruthy();
+            await settled(receipt(), "u1", "c");
+            const second = await f.store.aggregate(query({ limit: 1, cursor: first.nextCursor }));
+            expect(second.watermark).toBe(first.watermark);
+            expect(second.nextCursor).toBeUndefined();
+            expect([...first.rows, ...second.rows].map((r) => r.dimensions.provider)).toEqual(["a", "b"]);
+            expect((await f.store.aggregate(query())).rows).toHaveLength(3);
+            await expect(f.store.aggregate(query({ scope: { kind: "namespace", namespace: "other" }, cursor: first.nextCursor }))).rejects.toThrow("InvalidInput");
+        });
+        test("scope, connection, time and unit filters do not leak", async () => {
+            await settled();
+            for (const scope of [
+                { kind: "principal", namespace: "test", principal: "u2" },
+                { kind: "group", namespace: "test", group: "g2" },
+                { kind: "platform_pool", namespace: "test", poolId: "p2" },
+                { kind: "namespace", namespace: "other" },
+            ])
+                expect((await f.store.aggregate(query({ scope }))).rows).toHaveLength(0);
+            expect((await f.store.aggregate(query({ connection: "other" }))).rows).toHaveLength(0);
+            expect((await f.store.aggregate(query({ from: "2026-09-24T00:00:00Z" }))).rows).toHaveLength(0);
+            expect((await f.store.aggregate(query({ units: ["tokens"] }))).rows[0]?.measurements).toEqual([]);
+        });
+        const scopes = [
+            { kind: "principal", namespace: "test", principal: "u1" },
+            { kind: "group", namespace: "test", group: "g1" },
+            { kind: "connection", namespace: "test", connection: "c1" },
+            {
+                kind: "access_credential",
+                namespace: "test",
+                accessCredential: { kind: "api_key", id: "k1" },
+            },
+            { kind: "platform_pool", namespace: "test", poolId: "p1" },
+        ];
+        test.each(scopes)("defined budgets are exact: $kind", async (scope) => {
+            const b = budget({ scope });
+            f.budgets.push(b, budget({ scope: { ...scope, namespace: "other" } }));
+            expect(await f.store.definedBudgets({ scope })).toEqual([b]);
+        });
+        test("applicable statuses include settled and reserved quantities and unlimited bounds", async () => {
+            f.budgets.push(budget({ limit: quantity(5n) }), budget({ limit: null }));
+            await settled();
+            const i = input();
+            await f.store.reserve(i);
+            const statuses = await f.store.applicableBudgets({
+                scope: i.scope,
+                surface: i.surface,
+                units: ["requests"],
+            });
+            expect(statuses[0]).toMatchObject({
+                used: quantity(1n),
+                reserved: quantity(1n),
+                remaining: quantity(3n),
+            });
+            expect(statuses[1].remaining).toBeNull();
+        });
+        test("storage rejects money above capability on reserve and settle atomically", async () => {
+            await expect(f.store.reserve(input({ estimate: [quantity(capabilities.maxMoneyUnits + 1n, "cents", 4)] }))).rejects.toThrow("InvalidInput");
+            const i = input();
+            const r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            const g = await f.store.markDispatchIntent({
+                ...command(r.operation),
+                holder: "h",
+                leaseTtlMs: 1000,
+            });
+            if (!("granted" in g) || !g.granted)
+                throw new Error("fixture");
+            await expect(f.store.settle({
+                ...command(g.operation),
+                authority: { kind: "lease", leaseId: g.lease.leaseId },
+                receipt: receipt({
+                    cost: {
+                        certainty: "measured",
+                        money: { units: capabilities.maxMoneyUnits + 1n, currency: "USD" },
+                    },
+                }),
+            })).rejects.toThrow("InvalidInput");
+            expect(await f.store.getOperation(ref(i))).toEqual(g.operation);
+        });
+    });
+}

package/dist/conformance/recovery.d.ts

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

package/dist/conformance/recovery.js

@@ -0,0 +1,126 @@
+import { beforeEach, afterEach, describe, expect, test } from "vitest";
+import { input, command, ref, receipt, unknownReceipt } from "./helpers.js";
+export function recoveryTests(factory) {
+    describe("simulated process loss", () => {
+        let f;
+        beforeEach(async () => {
+            f = await factory();
+        });
+        afterEach(async () => f.close());
+        const reserve = async () => {
+            const r = await f.store.reserve(input());
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            return r.operation;
+        };
+        const grant = async () => {
+            const op = await reserve();
+            const g = await f.store.markDispatchIntent({
+                ...command(op),
+                holder: "old",
+                leaseTtlMs: 1000,
+            });
+            if (!("granted" in g) || !g.granted)
+                throw new Error("fixture");
+            return g;
+        };
+        test("lost holder cannot regain dispatch; recovery fences old settlement", async () => {
+            const g = await grant();
+            expect(await f.store.markDispatchIntent({
+                ...command(g.operation),
+                holder: "new",
+                leaseTtlMs: 1000,
+            })).toMatchObject({ granted: false, reason: "already_dispatched" });
+            f.clock.advance(1000);
+            const r = await f.store.claimForRecovery({
+                ...ref(g.operation),
+                holder: "new",
+                leaseTtlMs: 1000,
+            });
+            expect(r).toMatchObject({ claimed: true, lease: { holder: "new" } });
+            if (!("claimed" in r) || !r.claimed)
+                throw new Error("fixture");
+            expect(r.lease.leaseId).not.toBe(g.lease.leaseId);
+            expect(await f.store.settle({
+                ...command(r.operation),
+                authority: { kind: "lease", leaseId: g.lease.leaseId },
+                receipt: receipt(),
+            })).toMatchObject({ reason: "not_holder" });
+            expect(await f.store.settle({
+                ...command(r.operation),
+                authority: { kind: "recovery", leaseId: r.lease.leaseId },
+                receipt: receipt(),
+            })).toMatchObject({ outcome: "settled", operation: { state: "settled" } });
+        });
+        test("active lease, reserved, released, settled and missing claims fail", async () => {
+            const g = await grant();
+            const claim = { ...ref(g.operation), holder: "new", leaseTtlMs: 1000 };
+            expect(await f.store.claimForRecovery(claim)).toMatchObject({ reason: "lease_active" });
+            expect(await f.store.claimForRecovery({ ...claim, operationId: "missing" })).toEqual({
+                claimed: false,
+                reason: "not_found",
+                operation: null,
+            });
+            const reserved = await reserve();
+            expect(await f.store.claimForRecovery({ ...claim, ...ref(reserved) })).toMatchObject({
+                reason: "not_recoverable",
+            });
+            await f.store.releaseUndispatched({ ...command(reserved), reason: "cancel" });
+            expect(await f.store.claimForRecovery({ ...claim, ...ref(reserved) })).toMatchObject({
+                reason: "not_recoverable",
+            });
+            await f.store.settle({
+                ...command(g.operation),
+                authority: { kind: "lease", leaseId: g.lease.leaseId },
+                receipt: receipt(),
+            });
+            expect(await f.store.claimForRecovery(claim)).toMatchObject({ reason: "not_recoverable" });
+        });
+        test("concurrent recovery claims and a second expired recovery lease", async () => {
+            const g = await grant();
+            f.clock.advance(1000);
+            const claims = await Promise.all(["a", "b"].map((holder) => f.store.claimForRecovery({ ...ref(g.operation), holder, leaseTtlMs: 1000 })));
+            expect(claims.filter((c) => "claimed" in c && c.claimed)).toHaveLength(1);
+            const first = claims.find((c) => "claimed" in c && c.claimed);
+            if (!("claimed" in first) || !first.claimed)
+                throw new Error("fixture");
+            f.clock.advance(1000);
+            const second = await f.store.claimForRecovery({
+                ...ref(g.operation),
+                holder: "c",
+                leaseTtlMs: 1000,
+            });
+            if (!("claimed" in second) || !second.claimed)
+                throw new Error("fixture");
+            expect(second.lease.leaseId).not.toBe(first.lease.leaseId);
+            expect(await f.store.settle({
+                ...command(second.operation),
+                authority: { kind: "recovery", leaseId: first.lease.leaseId },
+                receipt: receipt(),
+            })).toMatchObject({ reason: "not_holder" });
+        });
+        test("pending claim corrects uncertain receipt", async () => {
+            const g = await grant();
+            const r = unknownReceipt();
+            await f.store.settle({
+                ...command(g.operation),
+                authority: { kind: "lease", leaseId: g.lease.leaseId },
+                receipt: r,
+            });
+            const claim = await f.store.claimForRecovery({
+                ...ref(g.operation),
+                holder: "recovery",
+                leaseTtlMs: 1000,
+            });
+            if (!("claimed" in claim) || !claim.claimed)
+                throw new Error("fixture");
+            expect(await f.store.correct({
+                ...command(claim.operation),
+                authority: { kind: "recovery", leaseId: claim.lease.leaseId },
+                receipt: receipt(),
+                replacesReceiptId: r.id,
+                reason: "provider evidence",
+            })).toMatchObject({ outcome: "settled", operation: { state: "settled" } });
+        });
+    });
+}

package/dist/conformance/reserve.d.ts

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

package/dist/conformance/reserve.js

@@ -0,0 +1,94 @@
+import { beforeEach, afterEach, describe, expect, test } from "vitest";
+import { input, ref, quantity } from "./helpers.js";
+export function reserveTests(factory) {
+    describe("reserve identity", () => {
+        let f;
+        beforeEach(async () => {
+            f = await factory();
+        });
+        afterEach(async () => f.close());
+        test("first reserve and isolated replay snapshots", async () => {
+            const i = input();
+            const first = await f.store.reserve(i);
+            if (first.outcome !== "reserved")
+                throw new Error("fixture");
+            expect(first).toMatchObject({
+                outcome: "reserved",
+                replayed: false,
+                operation: { state: "reserved", version: 1, receipts: [], lease: null },
+            });
+            expect(await f.store.reserve(i)).toEqual({ ...first, replayed: true });
+            i.scope.principal = "mutated";
+            expect(await f.store.getOperation({ ...ref(i), principal: "u1" })).toMatchObject({
+                scope: { principal: "u1" },
+            });
+        });
+        const changes = [
+            { scope: { namespace: "test", principal: "u2", connection: "c1" } },
+            { fundingSource: "platform" },
+            { costOwner: "other" },
+            { creditAccountRef: "wallet" },
+            { customerPriceVersion: "v2" },
+            { surface: "programmatic" },
+            { source: "mcp" },
+            { provider: "other" },
+            { operation: "other" },
+            { estimate: [quantity(2n)] },
+            { platformPools: ["pool"] },
+            ...["actor", "group", "providerCredentialVersion"].map((key) => ({
+                scope: { namespace: "test", principal: "u1", connection: "c1", [key]: "other" },
+            })),
+            { scope: { namespace: "test", principal: "u1", connection: "c2" } },
+            {
+                scope: {
+                    namespace: "test",
+                    principal: "u1",
+                    connection: "c1",
+                    accessCredential: { kind: "api_key", id: "k1" },
+                },
+            },
+        ];
+        test.each(changes)("semantic mismatch case", async (change) => {
+            const i = input();
+            const first = await f.store.reserve(i);
+            if (first.outcome !== "reserved")
+                throw new Error("fixture");
+            expect(await f.store.reserve({ ...i, ...change })).toEqual({
+                outcome: "conflict",
+                reason: "semantic_mismatch",
+                operation: first.operation,
+            });
+        });
+        test("namespace isolates identities", async () => {
+            const i = input();
+            await f.store.reserve(i);
+            expect(await f.store.reserve({ ...i, scope: { ...i.scope, namespace: "other" } })).toMatchObject({ replayed: false });
+        });
+        test("unit order, pool order and diagnostic ids are not semantic", async () => {
+            const i = input({ estimate: [quantity(), quantity(2n, "units")], platformPools: ["a", "b"] });
+            const first = await f.store.reserve(i);
+            if (first.outcome !== "reserved")
+                throw new Error("fixture");
+            expect(await f.store.reserve({
+                ...i,
+                estimate: [...i.estimate].reverse(),
+                platformPools: ["b", "a"],
+                correlationId: "other",
+                parentOperationId: "parent",
+            })).toEqual({ ...first, replayed: true });
+        });
+        test("concurrent reserve creates exactly one record", async () => {
+            const i = input();
+            const results = await Promise.all(Array.from({ length: 20 }, () => f.store.reserve(i)));
+            expect(results.filter((r) => r.outcome === "reserved" && !r.replayed)).toHaveLength(1);
+        });
+        test.each([
+            { value: -1n, scale: 0, unit: "requests" },
+            { value: 1.5, scale: 0, unit: "requests" },
+            { value: 1n, scale: -1, unit: "requests" },
+            { value: 1n, scale: 0, unit: "" },
+        ])("rejects invalid quantity case", async (q) => {
+            await expect(f.store.reserve(input({ estimate: [q] }))).rejects.toThrow("InvalidInput");
+        });
+    });
+}

package/dist/conformance/scaling.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from "../index.js";
+export type ScalingFixture = {
+    store: Store;
+    snapshot(): {
+        statements: number;
+        changes: bigint;
+        rowsRead: number;
+    };
+    readOnly(run: () => Promise<void>): Promise<void>;
+    close(): Promise<void>;
+};
+/** SQL adapters supply counters, never an implementation-specific Store to the test. */
+export declare function runStoreScalingConformance(factory: () => Promise<ScalingFixture>): void;

package/dist/conformance/scaling.js

@@ -0,0 +1,67 @@
+import { expect, test } from "vitest";
+import { input, command, receipt, ref } from "./helpers.js";
+/** SQL adapters supply counters, never an implementation-specific Store to the test. */
+export function runStoreScalingConformance(factory) {
+    test("5000 operations do not increase command statements or changed rows", async () => {
+        const f = await factory();
+        const execute = async (id) => {
+            const before = f.snapshot(), i = input({ operationId: id, provider: id }), r = await f.store.reserve(i);
+            if (r.outcome !== "reserved")
+                throw new Error("fixture");
+            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(),
+            });
+            const after = f.snapshot();
+            return {
+                statements: after.statements - before.statements,
+                changes: after.changes - before.changes,
+                rowsRead: after.rowsRead - before.rowsRead,
+            };
+        };
+        try {
+            const small = await execute("small");
+            for (let n = 0; n < 5000; n++)
+                await f.store.reserve(input({ operationId: `seed-${n}` }));
+            const large = await execute("large");
+            expect(large).toEqual(small);
+            expect(large.statements).toBeLessThan(75);
+            expect(large.changes).toBeLessThan(30n);
+            await f.readOnly(async () => {
+                expect(await f.store.getOperation(ref(input({ operationId: "large" })))).toMatchObject({
+                    state: "settled",
+                });
+                await f.store.definedBudgets({
+                    scope: { kind: "principal", namespace: "test", principal: "u1" },
+                });
+                await f.store.applicableBudgets({
+                    scope: input().scope,
+                    surface: "app",
+                    units: ["requests"],
+                });
+                const q = {
+                    scope: { kind: "namespace", namespace: "test" },
+                    from: "2026-09-01T00:00:00Z",
+                    to: "2026-10-01T00:00:00Z",
+                    units: ["requests"],
+                    groupBy: ["provider"],
+                    limit: 1,
+                }, first = await f.store.aggregate(q);
+                expect(first.nextCursor).toBeTruthy();
+                expect((await f.store.aggregate({ ...q, cursor: first.nextCursor })).watermark).toBe(first.watermark);
+            });
+            console.info(`Scaling: 5000 operations, ${large.statements} prepares, ${large.changes} changed rows, ${large.rowsRead} returned rows; same as small database. All reads and cursor pages pass read-only enforcement.`);
+        }
+        finally {
+            await f.close();
+        }
+    });
+}

package/dist/conformance/suite.d.ts

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

package/dist/conformance/suite.js

@@ -0,0 +1,27 @@
+import { describe, afterAll } from "vitest";
+import { expirationTests } from "./expiration.js";
+import { reserveTests } from "./reserve.js";
+import { admissionTests } from "./admission.js";
+import { dispatchTests } from "./dispatch.js";
+import { authorityTests } from "./authority.js";
+import { recoveryTests } from "./recovery.js";
+import { readsTests } from "./reads.js";
+import { propertyTests } from "./properties.js";
+import { capabilityTests } from "./capabilities.js";
+export function runStoreConformance(factory, capabilities) {
+    describe("store conformance", () => {
+        reserveTests(factory);
+        expirationTests(factory);
+        admissionTests(factory);
+        dispatchTests(factory);
+        authorityTests(factory);
+        recoveryTests(factory);
+        readsTests(factory, capabilities);
+        propertyTests(factory);
+        capabilityTests(factory, capabilities);
+        afterAll(() => console.info("Skipped guarantees: " +
+            [!capabilities.durable && "durable", !capabilities.rollingWindows && "rollingWindows"]
+                .filter(Boolean)
+                .join(", ")));
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import type { AdmissionPolicy } from "@usagekit/core";
+import type { ExpireReservationsInput, ExpireReservationsResult, Budget, ApplicableBudgetsQuery, BudgetStatus, DefinedBudgetsQuery, CorrectionInput, DispatchGrant, DispatchIntentInput, LeaseRenewal, LeaseRenewalInput, Operation, OperationRef, RecoveryClaim, RecoveryClaimInput, ReleaseInput, ReleaseResult, ReserveInput, ReserveResult, SettleInput, SettleResult, UsagePage, UsageQuery } from "@usagekit/core";
+/**
+ * Authorization is the Meter's job; atomic condition checks are the Store's job.
+ * Store does not take AccessContext. Meter resolves applicable budgets, funding and price policy.
+ * Each command atomically re-checks state, version, lease ownership, budget headroom
+ * including outstanding reservations, and command replay identity.
+ * A Meter-side check is never sufficient. Expected rejections return typed outcomes, not exceptions.
+ * Admission includes unsettled reservations across all applicable bounds.
+ * Reserve selects current budgets atomically by namespace, scope, surface, units and pools.
+ * Host ownership resolution, authorization and pool-figure redaction belong to Meter.
+ * Adapters prove these guarantees through one conformance suite, without callback locks.
+ */
+export interface Store {
+    expireReservations(input: ExpireReservationsInput): Promise<ExpireReservationsResult>;
+    reserve(input: ReserveInput, policy?: AdmissionPolicy): Promise<ReserveResult>;
+    markDispatchIntent(input: DispatchIntentInput): Promise<DispatchGrant>;
+    renewLease(input: LeaseRenewalInput): Promise<LeaseRenewal>;
+    claimForRecovery(input: RecoveryClaimInput): Promise<RecoveryClaim>;
+    settle(input: SettleInput): Promise<SettleResult>;
+    correct(input: CorrectionInput): Promise<SettleResult>;
+    releaseUndispatched(input: ReleaseInput): Promise<ReleaseResult>;
+    getOperation(input: OperationRef): Promise<Operation | null>;
+    aggregate(query: UsageQuery): Promise<UsagePage>;
+    definedBudgets(query: DefinedBudgetsQuery): Promise<readonly Budget[]>;
+    applicableBudgets(query: ApplicableBudgetsQuery): Promise<readonly BudgetStatus[]>;
+}
+export { createMemoryStore } from "./memory/memory-store.js";
+export { createManualClock } from "./clock.js";
+export type { Clock, ManualClock } from "./clock.js";
+export { InvalidInput } from "./memory/state.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createMemoryStore } from "./memory/memory-store.js";
+export { createManualClock } from "./clock.js";
+export { InvalidInput } from "./memory/state.js";

package/dist/memory/admission.d.ts

@@ -0,0 +1,44 @@
+import type { AdmissionPolicy } from "@usagekit/core";
+import type { Budget, ReserveInput, ApplicableBudgetsQuery, Quantity, BudgetStatus, AllowanceExceeded, Operation } from "@usagekit/core";
+import type { State } from "./state.js";
+export declare function currentBudgets(s: State): Budget[];
+export declare function matches(b: Budget, i: Pick<ReserveInput, "scope" | "surface" | "platformPools">): boolean;
+export declare function plus(a: Quantity, b: Quantity): Quantity;
+export declare const greater: (a: Quantity, b: Quantity) => boolean;
+export declare function effective(op: Operation): import("@usagekit/core").Receipt | undefined;
+export declare function status(s: State, b: Budget): BudgetStatus;
+export declare function applicable(s: State, i: ApplicableBudgetsQuery): BudgetStatus[];
+export declare function admission(s: State, i: ReserveInput, policy?: AdmissionPolicy): {
+    invalid: string;
+    warnings: AllowanceExceeded[];
+    epochs: {
+        budgetId: string;
+        budgetVersion: number;
+        epoch: string;
+        startsAt: string;
+        endsAt: string | null;
+    }[];
+    exceeded?: never;
+} | {
+    exceeded: AllowanceExceeded;
+    warnings: AllowanceExceeded[];
+    epochs: {
+        budgetId: string;
+        budgetVersion: number;
+        epoch: string;
+        startsAt: string;
+        endsAt: string | null;
+    }[];
+    invalid?: never;
+} | {
+    warnings: AllowanceExceeded[];
+    epochs: {
+        budgetId: string;
+        budgetVersion: number;
+        epoch: string;
+        startsAt: string;
+        endsAt: string | null;
+    }[];
+    invalid?: never;
+    exceeded?: never;
+};