mcp-usage-control-cloudflare 1.0.0

package/dist/index.js

@@ -0,0 +1,1487 @@
+import { UsageStateError, assertUsageIdentifier, validateUsageBudgetEnvelope, validateUsageRequestEnvelope, validateUsageVectorEnvelope, validateUsageVectorGrowthEnvelope, emitUsageEvent, } from 'mcp-usage-control';
+const RESERVATION_ID_PATTERN = /^cf1\.[a-f0-9]{64}$/;
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const DEFAULT_PATH = '/v1/usage-store';
+const MAX_GATEWAY_BODY_BYTES = 65_536;
+/** Worker-local UsageStore backed by a Durable Object namespace binding. */
+export class CloudflareUsageStore {
+    namespace;
+    options;
+    constructor(namespace, options = {}) {
+        this.namespace = namespace;
+        this.options = normalizeOptions(options);
+    }
+    async reserve(input) {
+        const prepared = await prepareReserve(input, this.options);
+        const envelope = await this.stub().reserve(prepared.command);
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapReserveReply(envelope.result, prepared, input.request, input.units);
+    }
+    async reserveVector(input) {
+        const prepared = await prepareVectorReserve(input, this.options);
+        const stub = this.stub();
+        if (!stub.reserveVector) {
+            throw new UsageStateError('Cloudflare Durable Object does not support atomic vector usage');
+        }
+        const envelope = await stub.reserveVector(prepared.command);
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorReserveReply(envelope.result, prepared, input.request);
+    }
+    async growVectorReservation(input) {
+        const prepared = await prepareVectorGrowth(input, this.options.idempotencyTtlMs);
+        const stub = this.stub();
+        if (!stub.growVector) {
+            throw new UsageStateError('Cloudflare Durable Object does not support atomic vector usage');
+        }
+        const envelope = await stub.growVector(prepared.command);
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorGrowthReply(envelope.result, input, prepared);
+    }
+    async settleVector(input) {
+        const prepared = await prepareVectorSettlement(input, this.options.idempotencyTtlMs);
+        const stub = this.stub();
+        if (!stub.settleVector) {
+            throw new UsageStateError('Cloudflare Durable Object does not support atomic vector usage');
+        }
+        const envelope = await stub.settleVector(prepared.command);
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorSettlementReply(envelope.result, input, prepared);
+    }
+    async growReservation(input) {
+        const prepared = await prepareGrowth(input, this.options.idempotencyTtlMs);
+        const stub = this.stub();
+        if (!stub.grow)
+            throw new UsageStateError('Cloudflare Durable Object does not support progressive growth');
+        const envelope = await stub.grow(prepared.command);
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapGrowthReply(envelope.result, input, prepared);
+    }
+    async markLiable(input) {
+        assertReservationId(input.reservationId);
+        const envelope = await this.stub().markLiable({
+            reservationId: input.reservationId,
+            idempotencyTtlMs: this.options.idempotencyTtlMs,
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return { reservationId: input.reservationId, expiresAt: envelope.result.expiresAt };
+    }
+    async renew(input) {
+        assertReservationId(input.reservationId);
+        assertPositiveInteger(input.ttlMs, 'ttlMs');
+        const envelope = await this.stub().renew({
+            reservationId: input.reservationId,
+            ttlMs: input.ttlMs,
+            idempotencyTtlMs: this.options.idempotencyTtlMs,
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return { reservationId: input.reservationId, expiresAt: envelope.result.expiresAt };
+    }
+    async settle(input) {
+        assertReservationId(input.reservationId);
+        assertNonNegativeInteger(input.actualUnits, 'actualUnits');
+        const outcomeHash = await digest(input.outcome);
+        const envelope = await this.stub().settle({
+            reservationId: input.reservationId,
+            actualUnits: input.actualUnits,
+            outcomeHash,
+            idempotencyTtlMs: this.options.idempotencyTtlMs,
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return {
+            reservationId: input.reservationId,
+            reservedUnits: envelope.result.reservedUnits,
+            actualUnits: envelope.result.actualUnits,
+            releasedUnits: envelope.result.releasedUnits,
+            outcome: input.outcome,
+        };
+    }
+    stub() {
+        return resolveStub(this.namespace, this.options.domainName);
+    }
+    emitRecovery(report) {
+        emitRecovery(this.options.observer, report);
+    }
+}
+export class CloudflareUsageTransportError extends Error {
+    code;
+    status;
+    constructor(code, 
+    /** Bounded HTTP status metadata when a response was received. Response bodies are never exposed. */
+    status) {
+        super('Cloudflare usage store transport failed');
+        this.code = code;
+        this.status = status;
+        this.name = 'CloudflareUsageTransportError';
+    }
+}
+/** Node/edge remote UsageStore for a separately deployed Cloudflare gateway Worker. */
+export class RemoteCloudflareUsageStore {
+    options;
+    endpoint;
+    fetchImpl;
+    timeoutMs;
+    observer;
+    constructor(options) {
+        this.options = options;
+        this.endpoint = new URL(options.endpoint);
+        const isLocalHttp = this.endpoint.protocol === 'http:' &&
+            (this.endpoint.hostname === '127.0.0.1' || this.endpoint.hostname === 'localhost');
+        if (this.endpoint.protocol !== 'https:' && !isLocalHttp) {
+            throw new RangeError('Cloudflare usage store endpoint must use HTTPS (local HTTP is test-only)');
+        }
+        if (this.endpoint.username || this.endpoint.password) {
+            throw new RangeError('Cloudflare usage store endpoint must not embed credentials');
+        }
+        this.fetchImpl = options.fetch ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        assertPositiveInteger(this.timeoutMs, 'timeoutMs');
+        assertPortableTimerDelay(this.timeoutMs, 'timeoutMs');
+        this.observer = options.observer;
+    }
+    async reserve(input) {
+        const prepared = await prepareReserve(input, {
+            cleanupBatchSize: 1,
+            idempotencyTtlMs: 1,
+        });
+        const envelope = await this.post({
+            version: 1,
+            method: 'reserve',
+            input: {
+                reservationId: prepared.command.reservationId,
+                units: prepared.command.units,
+                budgets: prepared.command.budgets,
+                ttlMs: prepared.command.ttlMs,
+                initialGrowthCursor: prepared.command.initialGrowthCursor,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapReserveReply(envelope.result, prepared, input.request, input.units);
+    }
+    async reserveVector(input) {
+        const prepared = await prepareVectorReserve(input, { cleanupBatchSize: 1, idempotencyTtlMs: 1 });
+        const envelope = await this.post({
+            version: 1,
+            method: 'reserve_vector',
+            input: {
+                reservationId: prepared.command.reservationId,
+                dimensions: prepared.command.dimensions,
+                ttlMs: prepared.command.ttlMs,
+                initialGrowthCursor: prepared.command.initialGrowthCursor,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorReserveReply(envelope.result, prepared, input.request);
+    }
+    async growVectorReservation(input) {
+        const prepared = await prepareVectorGrowth(input, 1);
+        const envelope = await this.post({
+            version: 1,
+            method: 'grow_vector',
+            input: {
+                reservationId: prepared.command.reservationId,
+                incrementHash: prepared.command.incrementHash,
+                expectedGrowthCursor: prepared.command.expectedGrowthCursor,
+                dimensions: prepared.command.dimensions,
+                fingerprint: prepared.command.fingerprint,
+                nextGrowthCursor: prepared.command.nextGrowthCursor,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorGrowthReply(envelope.result, input, prepared);
+    }
+    async settleVector(input) {
+        const prepared = await prepareVectorSettlement(input, 1);
+        const envelope = await this.post({
+            version: 1,
+            method: 'settle_vector',
+            input: {
+                reservationId: prepared.command.reservationId,
+                actualByDimension: prepared.command.actualByDimension,
+                outcomeHash: prepared.command.outcomeHash,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapVectorSettlementReply(envelope.result, input, prepared);
+    }
+    async growReservation(input) {
+        const prepared = await prepareGrowth(input, 1);
+        const envelope = await this.post({
+            version: 1,
+            method: 'grow',
+            input: {
+                reservationId: prepared.command.reservationId,
+                incrementHash: prepared.command.incrementHash,
+                expectedGrowthCursor: prepared.command.expectedGrowthCursor,
+                additionalUnits: prepared.command.additionalUnits,
+                budgets: prepared.command.budgets,
+                fingerprint: prepared.command.fingerprint,
+                nextGrowthCursor: prepared.command.nextGrowthCursor,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return mapGrowthReply(envelope.result, input, prepared);
+    }
+    async markLiable(input) {
+        assertReservationId(input.reservationId);
+        const envelope = await this.post({
+            version: 1,
+            method: 'mark_liable',
+            input: { reservationId: input.reservationId },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return { reservationId: input.reservationId, expiresAt: envelope.result.expiresAt };
+    }
+    async renew(input) {
+        assertReservationId(input.reservationId);
+        assertPositiveInteger(input.ttlMs, 'ttlMs');
+        const envelope = await this.post({
+            version: 1,
+            method: 'renew',
+            input: { reservationId: input.reservationId, ttlMs: input.ttlMs },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return { reservationId: input.reservationId, expiresAt: envelope.result.expiresAt };
+    }
+    async settle(input) {
+        assertReservationId(input.reservationId);
+        assertNonNegativeInteger(input.actualUnits, 'actualUnits');
+        const outcomeHash = await digest(input.outcome);
+        const envelope = await this.post({
+            version: 1,
+            method: 'settle',
+            input: {
+                reservationId: input.reservationId,
+                actualUnits: input.actualUnits,
+                outcomeHash,
+            },
+        });
+        this.emitRecovery(envelope.recovery);
+        if (!envelope.ok)
+            throw mapStoreError(envelope.error);
+        return {
+            reservationId: input.reservationId,
+            reservedUnits: envelope.result.reservedUnits,
+            actualUnits: envelope.result.actualUnits,
+            releasedUnits: envelope.result.releasedUnits,
+            outcome: input.outcome,
+        };
+    }
+    async post(body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            let resolvedHeaders;
+            try {
+                resolvedHeaders = await waitForAbort(resolveHeaders(this.options.headers), controller.signal);
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    throw new CloudflareUsageTransportError('timeout');
+                throw error;
+            }
+            const headers = new Headers(resolvedHeaders);
+            headers.set('content-type', 'application/json');
+            headers.set('accept', 'application/json');
+            let response;
+            try {
+                response = await waitForAbort(this.fetchImpl(this.endpoint, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                }), controller.signal);
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    throw new CloudflareUsageTransportError('timeout');
+                if (error instanceof CloudflareUsageTransportError)
+                    throw error;
+                throw new CloudflareUsageTransportError('network');
+            }
+            if (response.status === 401 || response.status === 403) {
+                throw new CloudflareUsageTransportError('unauthorized', response.status);
+            }
+            if (!response.ok)
+                throw new CloudflareUsageTransportError('remote', response.status);
+            let payload;
+            try {
+                payload = await waitForAbort(response.json(), controller.signal);
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    throw new CloudflareUsageTransportError('timeout');
+                if (error instanceof CloudflareUsageTransportError)
+                    throw error;
+                throw new CloudflareUsageTransportError('protocol', response.status);
+            }
+            if (!isEnvelopeForRequest(payload, body)) {
+                throw new CloudflareUsageTransportError('protocol', response.status);
+            }
+            return payload;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    emitRecovery(report) {
+        emitRecovery(this.observer, report);
+    }
+}
+/**
+ * Creates a public-HTTP-compatible Worker handler for non-Cloudflare callers.
+ * Authentication is mandatory and must be supplied by the application.
+ */
+export function createCloudflareUsageStoreGateway(options) {
+    const normalized = normalizeOptions(options);
+    const path = options.path ?? DEFAULT_PATH;
+    if (!path.startsWith('/'))
+        throw new RangeError('gateway path must start with /');
+    return async function handle(request) {
+        const url = new URL(request.url);
+        if (url.pathname !== path)
+            return responseJson({ error: 'not_found' }, 404);
+        if (request.method !== 'POST')
+            return responseJson({ error: 'method_not_allowed' }, 405);
+        let authorized = false;
+        try {
+            authorized = (await options.authorize(request)) === true;
+        }
+        catch {
+            authorized = false;
+        }
+        if (!authorized)
+            return responseJson({ error: 'unauthorized' }, 401);
+        const contentLength = Number(request.headers.get('content-length') ?? '0');
+        if (Number.isFinite(contentLength) && contentLength > MAX_GATEWAY_BODY_BYTES) {
+            return responseJson({ error: 'payload_too_large' }, 413);
+        }
+        let text;
+        try {
+            text = await request.text();
+        }
+        catch {
+            return responseJson({ error: 'invalid_request' }, 400);
+        }
+        if (new TextEncoder().encode(text).byteLength > MAX_GATEWAY_BODY_BYTES) {
+            return responseJson({ error: 'payload_too_large' }, 413);
+        }
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            return responseJson({ error: 'invalid_request' }, 400);
+        }
+        if (!isHttpRequest(body))
+            return responseJson({ error: 'invalid_request' }, 400);
+        const stub = resolveStub(options.namespace, normalized.domainName);
+        try {
+            const envelope = await invokeGateway(stub, body, normalized);
+            return responseJson(envelope, 200);
+        }
+        catch {
+            // Never serialize raw Durable Object/runtime exceptions to remote callers.
+            return responseJson({ error: 'store_unavailable' }, 503);
+        }
+    };
+}
+async function invokeGateway(stub, body, options) {
+    switch (body.method) {
+        case 'reserve':
+            return stub.reserve({
+                ...body.input,
+                cleanupBatchSize: options.cleanupBatchSize,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'reserve_vector':
+            if (!stub.reserveVector)
+                return failGatewayVectorUnsupported();
+            return stub.reserveVector({
+                ...body.input,
+                cleanupBatchSize: options.cleanupBatchSize,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'grow':
+            if (!stub.grow)
+                return failGatewayGrowthUnsupported();
+            return stub.grow({
+                ...body.input,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'grow_vector':
+            if (!stub.growVector)
+                return failGatewayVectorUnsupported();
+            return stub.growVector({
+                ...body.input,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'mark_liable':
+            return stub.markLiable({
+                reservationId: body.input.reservationId,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'renew':
+            return stub.renew({
+                reservationId: body.input.reservationId,
+                ttlMs: body.input.ttlMs,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'settle':
+            return stub.settle({
+                reservationId: body.input.reservationId,
+                actualUnits: body.input.actualUnits,
+                outcomeHash: body.input.outcomeHash,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+        case 'settle_vector':
+            if (!stub.settleVector)
+                return failGatewayVectorUnsupported();
+            return stub.settleVector({
+                reservationId: body.input.reservationId,
+                actualByDimension: body.input.actualByDimension,
+                outcomeHash: body.input.outcomeHash,
+                idempotencyTtlMs: options.idempotencyTtlMs,
+            });
+    }
+}
+function failGatewayGrowthUnsupported() {
+    return {
+        ok: false,
+        error: 'growth_not_supported',
+        recovery: {
+            aggregate: {
+                pendingCount: 0,
+                pendingUnits: 0,
+                liableCount: 0,
+                liableUnits: 0,
+                vectorPendingCount: 0,
+                vectorLiableCount: 0,
+            },
+        },
+    };
+}
+function failGatewayVectorUnsupported() {
+    return {
+        ok: false,
+        error: 'growth_not_supported',
+        recovery: {
+            aggregate: {
+                pendingCount: 0,
+                pendingUnits: 0,
+                liableCount: 0,
+                liableUnits: 0,
+                vectorPendingCount: 0,
+                vectorLiableCount: 0,
+            },
+        },
+    };
+}
+async function prepareReserve(input, options) {
+    validateRequestIdentity(input.request);
+    assertNonNegativeInteger(input.units, 'units');
+    assertPositiveInteger(input.ttlMs, 'ttlMs');
+    const budgets = canonicalizeBudgets(input.budgets);
+    const operationHash = await digest(JSON.stringify([
+        input.request.principal.tenantId ?? null,
+        input.request.principal.id,
+        input.request.tool,
+        input.request.operationId,
+    ]));
+    const reservationId = `cf1.${operationHash}`;
+    const budgetEntries = await Promise.all(budgets.map(async (budget) => ({ budget, id: await digest(budget.key) })));
+    const budgetById = new Map(budgetEntries.map(entry => [entry.id, entry.budget]));
+    const initialGrowthCursor = newGrowthCursor();
+    return {
+        reservationId,
+        budgets,
+        budgetById,
+        command: {
+            reservationId,
+            units: input.units,
+            budgets: budgetEntries.map(entry => ({ id: entry.id, limit: entry.budget.limit })),
+            ttlMs: input.ttlMs,
+            cleanupBatchSize: options.cleanupBatchSize,
+            idempotencyTtlMs: options.idempotencyTtlMs,
+            initialGrowthCursor,
+        },
+    };
+}
+async function prepareVectorReserve(input, options) {
+    validateRequestIdentity(input.request);
+    assertPositiveInteger(input.ttlMs, 'ttlMs');
+    const dimensions = canonicalizeUsageDimensions(input.dimensions);
+    const operationHash = await digest(JSON.stringify([
+        input.request.principal.tenantId ?? null,
+        input.request.principal.id,
+        input.request.tool,
+        input.request.operationId,
+    ]));
+    const reservationId = `cf1.${operationHash}`;
+    const encoded = await Promise.all(dimensions.map(async (dimension) => ({
+        dimension,
+        id: await digest(dimension.key),
+        budgets: await Promise.all(dimension.budgets.map(async (budget) => ({ budget, id: await digest(budget.key) }))),
+    })));
+    const dimensionById = new Map(encoded.map(entry => [entry.id, entry.dimension]));
+    const budgetById = new Map(encoded.flatMap(entry => entry.budgets.map(budget => [budget.id, budget.budget])));
+    return {
+        reservationId,
+        dimensions,
+        dimensionById,
+        budgetById,
+        command: {
+            reservationId,
+            dimensions: encoded.map(entry => ({
+                id: entry.id,
+                units: entry.dimension.units,
+                budgets: entry.budgets.map(budget => ({ id: budget.id, limit: budget.budget.limit })),
+            })),
+            ttlMs: input.ttlMs,
+            cleanupBatchSize: options.cleanupBatchSize,
+            idempotencyTtlMs: options.idempotencyTtlMs,
+            initialGrowthCursor: newGrowthCursor(),
+        },
+    };
+}
+async function prepareVectorGrowth(input, idempotencyTtlMs) {
+    assertReservationId(input.reservationId);
+    if (!input.incrementId)
+        throw new RangeError('incrementId must be a non-empty string');
+    if (!input.expectedGrowthCursor) {
+        throw new RangeError('expectedGrowthCursor must be a non-empty string');
+    }
+    assertPositiveInteger(idempotencyTtlMs, 'idempotencyTtlMs');
+    const dimensions = canonicalizeGrowthDimensions(input.dimensions);
+    const encoded = await Promise.all(dimensions.map(async (dimension) => ({
+        dimension,
+        id: await digest(dimension.key),
+        budgets: await Promise.all(dimension.budgets.map(async (budget) => ({ budget, id: await digest(budget.key) }))),
+    })));
+    const dimensionById = new Map(encoded.map(entry => [entry.id, entry.dimension]));
+    const budgetById = new Map(encoded.flatMap(entry => entry.budgets.map(budget => [budget.id, budget.budget])));
+    const encodedDimensions = encoded.map(entry => ({
+        id: entry.id,
+        additionalUnits: entry.dimension.additionalUnits,
+        budgets: entry.budgets.map(budget => ({ id: budget.id, limit: budget.budget.limit })),
+    }));
+    return {
+        dimensionById,
+        budgetById,
+        command: {
+            reservationId: input.reservationId,
+            incrementHash: await digest(input.incrementId),
+            expectedGrowthCursor: input.expectedGrowthCursor,
+            dimensions: encodedDimensions,
+            fingerprint: await digest(JSON.stringify(encodedDimensions.map(dimension => [
+                dimension.id,
+                dimension.additionalUnits,
+                dimension.budgets.map(budget => [budget.id, budget.limit]),
+            ]))),
+            nextGrowthCursor: newGrowthCursor(),
+            idempotencyTtlMs,
+        },
+    };
+}
+async function prepareVectorSettlement(input, idempotencyTtlMs) {
+    assertReservationId(input.reservationId);
+    assertPositiveInteger(idempotencyTtlMs, 'idempotencyTtlMs');
+    const actuals = canonicalizeActualDimensions(input.actualByDimension);
+    const encoded = await Promise.all(actuals.map(async (actual) => ({ actual, id: await digest(actual.key) })));
+    return {
+        dimensionKeyById: new Map(encoded.map(entry => [entry.id, entry.actual.key])),
+        command: {
+            reservationId: input.reservationId,
+            actualByDimension: encoded.map(entry => ({ id: entry.id, actualUnits: entry.actual.actualUnits })),
+            outcomeHash: await digest(input.outcome),
+            idempotencyTtlMs,
+        },
+    };
+}
+function mapVectorReserveReply(reply, prepared, request) {
+    if (!reply.accepted) {
+        if (reply.reason === 'duplicate_operation')
+            return { accepted: false, reason: reply.reason };
+        if (!reply.limitingDimensionId || !reply.limitingBudgetId || reply.remaining === undefined) {
+            throw new UsageStateError('Cloudflare vector quota reply was incomplete');
+        }
+        const dimension = prepared.dimensionById.get(reply.limitingDimensionId);
+        const budget = prepared.budgetById.get(reply.limitingBudgetId);
+        if (!dimension || !budget) {
+            throw new UsageStateError('Cloudflare vector quota reply referenced unknown identifiers');
+        }
+        return {
+            accepted: false,
+            reason: 'quota_exceeded',
+            limitingDimensionKey: dimension.key,
+            limitingBudgetKey: budget.key,
+            remaining: reply.remaining,
+        };
+    }
+    const remainingByBudget = reply.remainingByBudget.map(balance => {
+        const dimension = prepared.dimensionById.get(balance.dimensionId);
+        const budget = prepared.budgetById.get(balance.budgetId);
+        if (!dimension || !budget) {
+            throw new UsageStateError('Cloudflare vector reserve reply referenced unknown identifiers');
+        }
+        return { dimensionKey: dimension.key, budgetKey: budget.key, remaining: balance.remaining };
+    });
+    if (remainingByBudget.length !== prepared.budgetById.size) {
+        throw new UsageStateError('Cloudflare vector reserve reply omitted a budget balance');
+    }
+    return {
+        accepted: true,
+        reservation: {
+            id: prepared.reservationId,
+            operationId: request.operationId,
+            principalId: request.principal.id,
+            ...(request.principal.tenantId === undefined ? {} : { tenantId: request.principal.tenantId }),
+            ...(request.principal.plan === undefined ? {} : { plan: request.principal.plan }),
+            tool: request.tool,
+            dimensions: prepared.dimensions.map(dimension => ({
+                key: dimension.key,
+                budgetKeys: dimension.budgets.map(budget => budget.key),
+                reservedUnits: dimension.units,
+            })),
+            expiresAt: reply.expiresAt,
+            growthCursor: prepared.command.initialGrowthCursor,
+        },
+        remainingByBudget,
+    };
+}
+function mapVectorGrowthReply(reply, input, prepared) {
+    if (!reply.accepted) {
+        const dimension = prepared.dimensionById.get(reply.limitingDimensionId);
+        const budget = prepared.budgetById.get(reply.limitingBudgetId);
+        if (!dimension || !budget) {
+            throw new UsageStateError('Cloudflare vector growth denial referenced unknown identifiers');
+        }
+        return {
+            accepted: false,
+            reason: 'quota_exceeded',
+            replayed: reply.replayed,
+            reservationId: input.reservationId,
+            incrementId: input.incrementId,
+            growthCursor: reply.growthCursor,
+            limitingDimensionKey: dimension.key,
+            limitingBudgetKey: budget.key,
+            remaining: reply.remaining,
+        };
+    }
+    const mapReserved = (items) => items.map(item => {
+        const dimension = prepared.dimensionById.get(item.id);
+        if (!dimension)
+            throw new UsageStateError('Cloudflare vector growth reply referenced unknown dimension');
+        return { key: dimension.key, reservedUnits: item.reservedUnits };
+    });
+    const remainingByBudget = reply.remainingByBudget.map(balance => {
+        const dimension = prepared.dimensionById.get(balance.dimensionId);
+        const budget = prepared.budgetById.get(balance.budgetId);
+        if (!dimension || !budget) {
+            throw new UsageStateError('Cloudflare vector growth reply referenced unknown identifiers');
+        }
+        return { dimensionKey: dimension.key, budgetKey: budget.key, remaining: balance.remaining };
+    });
+    if (remainingByBudget.length !== prepared.budgetById.size) {
+        throw new UsageStateError('Cloudflare vector growth reply omitted a budget balance');
+    }
+    return {
+        accepted: true,
+        replayed: reply.replayed,
+        reservationId: input.reservationId,
+        incrementId: input.incrementId,
+        previousReservedByDimension: mapReserved(reply.previousReservedByDimension),
+        reservedByDimension: mapReserved(reply.reservedByDimension),
+        growthCursor: reply.growthCursor,
+        remainingByBudget,
+    };
+}
+function mapVectorSettlementReply(reply, input, prepared) {
+    return {
+        reservationId: input.reservationId,
+        dimensions: reply.dimensions.map(dimension => {
+            const key = prepared.dimensionKeyById.get(dimension.id);
+            if (!key)
+                throw new UsageStateError('Cloudflare vector settlement referenced unknown dimension');
+            return {
+                key,
+                reservedUnits: dimension.reservedUnits,
+                actualUnits: dimension.actualUnits,
+                releasedUnits: dimension.releasedUnits,
+            };
+        }),
+        outcome: input.outcome,
+    };
+}
+async function prepareGrowth(input, idempotencyTtlMs) {
+    assertReservationId(input.reservationId);
+    assertUsageIdentifier(input.incrementId, 'incrementId');
+    if (typeof input.expectedGrowthCursor !== 'string' ||
+        input.expectedGrowthCursor.length === 0) {
+        throw new RangeError('expectedGrowthCursor must be a non-empty string');
+    }
+    assertPositiveInteger(input.additionalUnits, 'additionalUnits');
+    assertPositiveInteger(idempotencyTtlMs, 'idempotencyTtlMs');
+    const budgets = canonicalizeBudgets(input.budgets);
+    const budgetEntries = await Promise.all(budgets.map(async (budget) => ({ budget, id: await digest(budget.key) })));
+    const budgetById = new Map(budgetEntries.map(entry => [entry.id, entry.budget]));
+    const encodedBudgets = budgetEntries.map(entry => ({ id: entry.id, limit: entry.budget.limit }));
+    return {
+        budgetById,
+        command: {
+            reservationId: input.reservationId,
+            incrementHash: await digest(input.incrementId),
+            expectedGrowthCursor: input.expectedGrowthCursor,
+            additionalUnits: input.additionalUnits,
+            budgets: encodedBudgets,
+            fingerprint: await digest(JSON.stringify([
+                input.additionalUnits,
+                encodedBudgets.map(budget => [budget.id, budget.limit]),
+            ])),
+            nextGrowthCursor: newGrowthCursor(),
+            idempotencyTtlMs,
+        },
+    };
+}
+function mapGrowthReply(reply, input, prepared) {
+    if (!reply.accepted) {
+        const budget = prepared.budgetById.get(reply.limitingBudgetId);
+        if (!budget)
+            throw new UsageStateError('Cloudflare growth quota reply referenced an unknown budget');
+        return {
+            accepted: false,
+            reason: 'quota_exceeded',
+            replayed: reply.replayed,
+            reservationId: input.reservationId,
+            incrementId: input.incrementId,
+            growthCursor: reply.growthCursor,
+            limitingBudgetKey: budget.key,
+            remaining: reply.remaining,
+        };
+    }
+    const remainingByBudget = reply.remainingByBudget.map(balance => {
+        const budget = prepared.budgetById.get(balance.id);
+        if (!budget)
+            throw new UsageStateError('Cloudflare growth reply referenced an unknown budget');
+        return { key: budget.key, remaining: balance.remaining };
+    });
+    if (remainingByBudget.length !== prepared.budgetById.size) {
+        throw new UsageStateError('Cloudflare growth reply omitted a budget balance');
+    }
+    return {
+        accepted: true,
+        replayed: reply.replayed,
+        reservationId: input.reservationId,
+        incrementId: input.incrementId,
+        previousReservedUnits: reply.previousReservedUnits,
+        reservedUnits: reply.reservedUnits,
+        growthCursor: reply.growthCursor,
+        remainingByBudget,
+    };
+}
+function mapReserveReply(reply, prepared, request, units) {
+    if (!reply.accepted) {
+        if (reply.reason === 'duplicate_operation')
+            return { accepted: false, reason: reply.reason };
+        if (!reply.limitingBudgetId || reply.remaining === undefined) {
+            throw new UsageStateError('Cloudflare quota reply was incomplete');
+        }
+        const budget = prepared.budgetById.get(reply.limitingBudgetId);
+        if (!budget)
+            throw new UsageStateError('Cloudflare quota reply referenced an unknown budget');
+        return {
+            accepted: false,
+            reason: 'quota_exceeded',
+            limitingBudgetKey: budget.key,
+            remaining: reply.remaining,
+        };
+    }
+    const remainingByBudget = reply.remainingByBudget.map(balance => {
+        const budget = prepared.budgetById.get(balance.id);
+        if (!budget)
+            throw new UsageStateError('Cloudflare reserve reply referenced an unknown budget');
+        return { key: budget.key, remaining: balance.remaining };
+    });
+    if (remainingByBudget.length !== prepared.budgets.length) {
+        throw new UsageStateError('Cloudflare reserve reply omitted a budget balance');
+    }
+    return {
+        accepted: true,
+        reservation: {
+            id: prepared.reservationId,
+            operationId: request.operationId,
+            principalId: request.principal.id,
+            ...(request.principal.tenantId === undefined ? {} : { tenantId: request.principal.tenantId }),
+            ...(request.principal.plan === undefined ? {} : { plan: request.principal.plan }),
+            tool: request.tool,
+            budgetKeys: prepared.budgets.map(budget => budget.key),
+            reservedUnits: units,
+            expiresAt: reply.expiresAt,
+            growthCursor: prepared.command.initialGrowthCursor,
+        },
+        remainingByBudget,
+    };
+}
+function emitRecovery(observer, report) {
+    if (report.direct) {
+        if ('vector' in report.direct) {
+            emitUsageEvent(observer, {
+                type: 'vector.reservation.recovered',
+                timestamp: Date.now(),
+                store: 'cloudflare',
+                recovery: report.direct.state === 'pending' ? 'pending_released' : 'liable_retained',
+                reservationId: report.direct.reservationId,
+                dimensionCount: report.direct.dimensionCount,
+                budgetCount: report.direct.budgetCount,
+                count: 1,
+            });
+        }
+        else {
+            emitUsageEvent(observer, {
+                type: 'reservation.recovered',
+                timestamp: Date.now(),
+                store: 'cloudflare',
+                recovery: report.direct.state === 'pending' ? 'pending_released' : 'liable_retained',
+                reservationId: report.direct.reservationId,
+                reservedUnits: report.direct.reservedUnits,
+                count: 1,
+            });
+        }
+    }
+    if (report.aggregate.pendingCount > 0) {
+        emitUsageEvent(observer, {
+            type: 'reservation.recovered',
+            timestamp: Date.now(),
+            store: 'cloudflare',
+            recovery: 'pending_released',
+            reservedUnits: report.aggregate.pendingUnits,
+            count: report.aggregate.pendingCount,
+        });
+    }
+    if (report.aggregate.liableCount > 0) {
+        emitUsageEvent(observer, {
+            type: 'reservation.recovered',
+            timestamp: Date.now(),
+            store: 'cloudflare',
+            recovery: 'liable_retained',
+            reservedUnits: report.aggregate.liableUnits,
+            count: report.aggregate.liableCount,
+        });
+    }
+    if ((report.aggregate.vectorPendingCount ?? 0) > 0) {
+        emitUsageEvent(observer, {
+            type: 'vector.reservation.recovered',
+            timestamp: Date.now(),
+            store: 'cloudflare',
+            recovery: 'pending_released',
+            count: report.aggregate.vectorPendingCount ?? 0,
+        });
+    }
+    if ((report.aggregate.vectorLiableCount ?? 0) > 0) {
+        emitUsageEvent(observer, {
+            type: 'vector.reservation.recovered',
+            timestamp: Date.now(),
+            store: 'cloudflare',
+            recovery: 'liable_retained',
+            count: report.aggregate.vectorLiableCount ?? 0,
+        });
+    }
+}
+function mapStoreError(code) {
+    switch (code) {
+        case 'settlement_conflict':
+            return new UsageStateError('Reservation was already settled with a different result');
+        case 'actual_units_exceed_reserved':
+            return new UsageStateError('actualUnits cannot exceed reservedUnits');
+        case 'growth_conflict':
+            return new UsageStateError('Growth increment was already attempted with different parameters');
+        case 'growth_stale_cursor':
+            return new UsageStateError('Growth cursor is stale or conflicts with reservation state');
+        case 'growth_budget_mismatch':
+            return new UsageStateError('Growth budgets must exactly match the reservation budget set');
+        case 'growth_not_supported':
+            return new UsageStateError('Reservation does not support requested growth/capability');
+        case 'vector_dimension_mismatch':
+            return new UsageStateError('Vector dimensions and budgets must exactly match the reservation');
+        case 'usage_mode_mismatch':
+            return new UsageStateError('Usage reservation mode does not match the requested operation');
+        case 'not_found_or_expired':
+            return new UsageStateError('Reservation not found or expired');
+    }
+}
+function resolveStub(namespace, domainName) {
+    if (namespace.getByName)
+        return namespace.getByName(domainName);
+    if (namespace.idFromName && namespace.get)
+        return namespace.get(namespace.idFromName(domainName));
+    throw new TypeError('Durable Object namespace must provide getByName() or idFromName()+get()');
+}
+function normalizeOptions(options) {
+    const domainName = options.domainName ?? 'default';
+    const cleanupBatchSize = options.cleanupBatchSize ?? 256;
+    const idempotencyTtlMs = options.idempotencyTtlMs ?? 86_400_000;
+    if (domainName.length === 0 || domainName.length > 128) {
+        throw new RangeError('domainName must be between 1 and 128 characters');
+    }
+    assertPositiveInteger(cleanupBatchSize, 'cleanupBatchSize');
+    assertPositiveInteger(idempotencyTtlMs, 'idempotencyTtlMs');
+    return {
+        domainName,
+        cleanupBatchSize,
+        idempotencyTtlMs,
+        ...(options.observer === undefined ? {} : { observer: options.observer }),
+    };
+}
+function canonicalizeUsageDimensions(dimensions) {
+    if (dimensions.length === 0)
+        throw new RangeError('dimensions must contain at least one dimension');
+    const normalized = dimensions.map(dimension => {
+        if (typeof dimension.key !== 'string' || dimension.key.length === 0)
+            throw new RangeError('dimension.key must be a non-empty string');
+        assertNonNegativeInteger(dimension.units, `dimension.units (${dimension.key})`);
+        return { key: dimension.key, units: dimension.units, budgets: canonicalizeBudgets(dimension.budgets) };
+    });
+    normalized.sort((a, b) => a.key.localeCompare(b.key));
+    validateVectorTopology(normalized);
+    return normalized;
+}
+function canonicalizeGrowthDimensions(dimensions) {
+    if (dimensions.length === 0)
+        throw new RangeError('dimensions must contain at least one dimension');
+    const normalized = dimensions.map(dimension => {
+        if (typeof dimension.key !== 'string' || dimension.key.length === 0)
+            throw new RangeError('dimension.key must be a non-empty string');
+        assertNonNegativeInteger(dimension.additionalUnits, `dimension.additionalUnits (${dimension.key})`);
+        return {
+            key: dimension.key,
+            additionalUnits: dimension.additionalUnits,
+            budgets: canonicalizeBudgets(dimension.budgets),
+        };
+    });
+    normalized.sort((a, b) => a.key.localeCompare(b.key));
+    validateVectorTopology(normalized);
+    if (!normalized.some(dimension => dimension.additionalUnits > 0)) {
+        throw new RangeError('vector growth must add units to at least one dimension');
+    }
+    return normalized;
+}
+function canonicalizeActualDimensions(actuals) {
+    if (actuals.length === 0)
+        throw new RangeError('actualByDimension must contain at least one dimension');
+    const normalized = actuals.map(actual => {
+        if (typeof actual.key !== 'string' || actual.key.length === 0)
+            throw new RangeError('actual dimension key must be a non-empty string');
+        assertNonNegativeInteger(actual.actualUnits, `actualUnits (${actual.key})`);
+        return { key: actual.key, actualUnits: actual.actualUnits };
+    });
+    normalized.sort((a, b) => a.key.localeCompare(b.key));
+    for (let index = 1; index < normalized.length; index += 1) {
+        if (normalized[index - 1].key === normalized[index].key) {
+            throw new RangeError(`duplicate dimension key: ${normalized[index].key}`);
+        }
+    }
+    return normalized;
+}
+function validateVectorTopology(dimensions) {
+    const dimensionKeys = new Set();
+    const budgetKeys = new Set();
+    for (const dimension of dimensions) {
+        if (dimensionKeys.has(dimension.key))
+            throw new RangeError(`duplicate dimension key: ${dimension.key}`);
+        dimensionKeys.add(dimension.key);
+        for (const budget of dimension.budgets) {
+            if (budgetKeys.has(budget.key)) {
+                throw new RangeError(`budget key cannot appear in multiple vector dimensions: ${budget.key}`);
+            }
+            budgetKeys.add(budget.key);
+        }
+    }
+}
+function canonicalizeBudgets(budgets) {
+    if (budgets.length === 0)
+        throw new RangeError('budgets must contain at least one budget');
+    const normalized = budgets.map(budget => {
+        if (typeof budget.key !== 'string' || budget.key.length === 0) {
+            throw new RangeError('budget.key must be a non-empty string');
+        }
+        assertNonNegativeInteger(budget.limit, `budget.limit (${budget.key})`);
+        return { key: budget.key, limit: budget.limit };
+    });
+    normalized.sort((a, b) => a.key.localeCompare(b.key));
+    for (let index = 1; index < normalized.length; index += 1) {
+        if (normalized[index - 1].key === normalized[index].key) {
+            throw new RangeError(`duplicate budget key: ${normalized[index].key}`);
+        }
+    }
+    return normalized;
+}
+function validateRequestIdentity(request) {
+    validateUsageRequestEnvelope(request);
+}
+function assertReservationId(value) {
+    if (!RESERVATION_ID_PATTERN.test(value))
+        throw new UsageStateError('Invalid Cloudflare reservation ID');
+}
+function assertNonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+function assertPortableTimerDelay(value, name) {
+    if (value > 2_147_483_647) {
+        throw new RangeError(`${name} must not exceed 2147483647ms`);
+    }
+}
+function assertPositiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive safe integer`);
+    }
+}
+function newGrowthCursor() {
+    return `g1.${crypto.randomUUID()}`;
+}
+async function digest(value) {
+    const bytes = new TextEncoder().encode(value);
+    const hash = await crypto.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(hash), byte => byte.toString(16).padStart(2, '0')).join('');
+}
+async function resolveHeaders(headers) {
+    if (typeof headers === 'function')
+        return headers();
+    return headers;
+}
+function waitForAbort(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(new Error('operation aborted'));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            cleanup();
+            reject(new Error('operation aborted'));
+        };
+        const cleanup = () => signal.removeEventListener('abort', onAbort);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(value => {
+            cleanup();
+            resolve(value);
+        }, error => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+function isHttpRequest(value) {
+    if (!isRecord(value) || value.version !== 1 || typeof value.method !== 'string' || !isRecord(value.input)) {
+        return false;
+    }
+    const input = value.input;
+    switch (value.method) {
+        case 'reserve':
+            return (isReservationId(input.reservationId) &&
+                isNonNegativeInteger(input.units) &&
+                isPositiveInteger(input.ttlMs) &&
+                typeof input.initialGrowthCursor === 'string' &&
+                input.initialGrowthCursor.length > 0 &&
+                Array.isArray(input.budgets) &&
+                input.budgets.length > 0 &&
+                input.budgets.every(budget => isRecord(budget) &&
+                    typeof budget.id === 'string' &&
+                    HASH_PATTERN.test(budget.id) &&
+                    isNonNegativeInteger(budget.limit)));
+        case 'reserve_vector':
+            return (isReservationId(input.reservationId) &&
+                isPositiveInteger(input.ttlMs) &&
+                typeof input.initialGrowthCursor === 'string' &&
+                input.initialGrowthCursor.length > 0 &&
+                isHashedDimensions(input.dimensions, 'reserve'));
+        case 'grow':
+            return (isReservationId(input.reservationId) &&
+                typeof input.incrementHash === 'string' &&
+                HASH_PATTERN.test(input.incrementHash) &&
+                typeof input.expectedGrowthCursor === 'string' &&
+                input.expectedGrowthCursor.length > 0 &&
+                isPositiveInteger(input.additionalUnits) &&
+                Array.isArray(input.budgets) &&
+                input.budgets.length > 0 &&
+                input.budgets.every(budget => isRecord(budget) &&
+                    typeof budget.id === 'string' &&
+                    HASH_PATTERN.test(budget.id) &&
+                    isNonNegativeInteger(budget.limit)) &&
+                typeof input.fingerprint === 'string' &&
+                HASH_PATTERN.test(input.fingerprint) &&
+                typeof input.nextGrowthCursor === 'string' &&
+                input.nextGrowthCursor.length > 0);
+        case 'grow_vector':
+            return (isReservationId(input.reservationId) &&
+                typeof input.incrementHash === 'string' &&
+                HASH_PATTERN.test(input.incrementHash) &&
+                typeof input.expectedGrowthCursor === 'string' &&
+                input.expectedGrowthCursor.length > 0 &&
+                isHashedDimensions(input.dimensions, 'growth') &&
+                typeof input.fingerprint === 'string' &&
+                HASH_PATTERN.test(input.fingerprint) &&
+                typeof input.nextGrowthCursor === 'string' &&
+                input.nextGrowthCursor.length > 0);
+        case 'mark_liable':
+            return isReservationId(input.reservationId);
+        case 'renew':
+            return isReservationId(input.reservationId) && isPositiveInteger(input.ttlMs);
+        case 'settle':
+            return (isReservationId(input.reservationId) &&
+                isNonNegativeInteger(input.actualUnits) &&
+                typeof input.outcomeHash === 'string' &&
+                HASH_PATTERN.test(input.outcomeHash));
+        case 'settle_vector':
+            return (isReservationId(input.reservationId) &&
+                Array.isArray(input.actualByDimension) &&
+                input.actualByDimension.length > 0 &&
+                input.actualByDimension.every(dimension => isRecord(dimension) &&
+                    typeof dimension.id === 'string' &&
+                    HASH_PATTERN.test(dimension.id) &&
+                    isNonNegativeInteger(dimension.actualUnits)) &&
+                typeof input.outcomeHash === 'string' &&
+                HASH_PATTERN.test(input.outcomeHash));
+        default:
+            return false;
+    }
+}
+function isHashedDimensions(value, mode) {
+    if (!Array.isArray(value) || value.length === 0)
+        return false;
+    return value.every(dimension => {
+        if (!isRecord(dimension) || typeof dimension.id !== 'string' || !HASH_PATTERN.test(dimension.id)) {
+            return false;
+        }
+        const units = mode === 'reserve' ? dimension.units : dimension.additionalUnits;
+        if (!isNonNegativeInteger(units))
+            return false;
+        return (Array.isArray(dimension.budgets) &&
+            dimension.budgets.length > 0 &&
+            dimension.budgets.every(budget => isRecord(budget) &&
+                typeof budget.id === 'string' &&
+                HASH_PATTERN.test(budget.id) &&
+                isNonNegativeInteger(budget.limit)));
+    });
+}
+function isEnvelopeForRequest(value, request) {
+    if (!isRecord(value) || typeof value.ok !== 'boolean' || !isRecoveryReport(value.recovery)) {
+        return false;
+    }
+    if (!value.ok)
+        return isStoreErrorCode(value.error);
+    return isSuccessfulReplyForRequest(value.result, request);
+}
+function isStoreErrorCode(value) {
+    return (typeof value === 'string' &&
+        [
+            'not_found_or_expired',
+            'settlement_conflict',
+            'actual_units_exceed_reserved',
+            'growth_conflict',
+            'growth_stale_cursor',
+            'growth_budget_mismatch',
+            'growth_not_supported',
+            'vector_dimension_mismatch',
+            'usage_mode_mismatch',
+        ].includes(value));
+}
+function isSuccessfulReplyForRequest(value, request) {
+    switch (request.method) {
+        case 'reserve':
+            return isReserveReplyForRequest(value, request.input.budgets.map(budget => budget.id));
+        case 'reserve_vector':
+            return isVectorReserveReplyForRequest(value, request.input.dimensions);
+        case 'grow':
+            return isGrowReplyForRequest(value, request.input);
+        case 'grow_vector':
+            return isVectorGrowReplyForRequest(value, request.input.dimensions);
+        case 'mark_liable':
+        case 'renew':
+            return isRecord(value) && isPositiveInteger(value.expiresAt);
+        case 'settle':
+            return isSettlementReplyForRequest(value, request.input.actualUnits);
+        case 'settle_vector':
+            return isVectorSettlementReplyForRequest(value, request.input.actualByDimension);
+    }
+}
+function isReserveReplyForRequest(value, expectedBudgetIds) {
+    if (!isRecord(value) || typeof value.accepted !== 'boolean')
+        return false;
+    if (value.accepted) {
+        return (isPositiveInteger(value.expiresAt) &&
+            isExactBudgetBalances(value.remainingByBudget, expectedBudgetIds));
+    }
+    if (value.reason === 'duplicate_operation') {
+        return ((value.limitingBudgetId === undefined || isExpectedHash(value.limitingBudgetId, expectedBudgetIds)) &&
+            (value.remaining === undefined || isNonNegativeInteger(value.remaining)));
+    }
+    return (value.reason === 'quota_exceeded' &&
+        isExpectedHash(value.limitingBudgetId, expectedBudgetIds) &&
+        isNonNegativeInteger(value.remaining));
+}
+function isVectorReserveReplyForRequest(value, dimensions) {
+    if (!isRecord(value) || typeof value.accepted !== 'boolean')
+        return false;
+    if (value.accepted) {
+        return (isPositiveInteger(value.expiresAt) &&
+            isExactVectorBalances(value.remainingByBudget, dimensions));
+    }
+    if (value.reason === 'duplicate_operation') {
+        return ((value.limitingDimensionId === undefined || isExpectedDimensionId(value.limitingDimensionId, dimensions)) &&
+            (value.limitingBudgetId === undefined || isExpectedVectorBudgetId(value.limitingBudgetId, dimensions)) &&
+            (value.remaining === undefined || isNonNegativeInteger(value.remaining)));
+    }
+    return (value.reason === 'quota_exceeded' &&
+        isExpectedVectorPair(value.limitingDimensionId, value.limitingBudgetId, dimensions) &&
+        isNonNegativeInteger(value.remaining));
+}
+function isGrowReplyForRequest(value, input) {
+    if (!isRecord(value) ||
+        typeof value.accepted !== 'boolean' ||
+        typeof value.replayed !== 'boolean' ||
+        !isNonEmptyString(value.growthCursor)) {
+        return false;
+    }
+    const expectedBudgetIds = input.budgets.map(budget => budget.id);
+    if (!value.accepted) {
+        return (value.reason === 'quota_exceeded' &&
+            isExpectedHash(value.limitingBudgetId, expectedBudgetIds) &&
+            isNonNegativeInteger(value.remaining));
+    }
+    if (!isNonNegativeInteger(value.previousReservedUnits) ||
+        !isNonNegativeInteger(value.reservedUnits) ||
+        value.previousReservedUnits > Number.MAX_SAFE_INTEGER - input.additionalUnits ||
+        value.reservedUnits !== value.previousReservedUnits + input.additionalUnits) {
+        return false;
+    }
+    return isExactBudgetBalances(value.remainingByBudget, expectedBudgetIds);
+}
+function isVectorGrowReplyForRequest(value, dimensions) {
+    if (!isRecord(value) ||
+        typeof value.accepted !== 'boolean' ||
+        typeof value.replayed !== 'boolean' ||
+        !isNonEmptyString(value.growthCursor)) {
+        return false;
+    }
+    if (!value.accepted) {
+        return (value.reason === 'quota_exceeded' &&
+            isExpectedVectorGrowthPair(value.limitingDimensionId, value.limitingBudgetId, dimensions) &&
+            isNonNegativeInteger(value.remaining));
+    }
+    const expectedIds = dimensions.map(dimension => dimension.id);
+    const previous = reservedDimensionMap(value.previousReservedByDimension, expectedIds);
+    const current = reservedDimensionMap(value.reservedByDimension, expectedIds);
+    if (!previous || !current)
+        return false;
+    for (const dimension of dimensions) {
+        const before = previous.get(dimension.id);
+        const after = current.get(dimension.id);
+        if (before === undefined ||
+            after === undefined ||
+            before > Number.MAX_SAFE_INTEGER - dimension.additionalUnits ||
+            after !== before + dimension.additionalUnits) {
+            return false;
+        }
+    }
+    return isExactVectorGrowthBalances(value.remainingByBudget, dimensions);
+}
+function isSettlementReplyForRequest(value, expectedActualUnits) {
+    if (!isRecord(value) ||
+        !isNonNegativeInteger(value.reservedUnits) ||
+        !isNonNegativeInteger(value.actualUnits) ||
+        !isNonNegativeInteger(value.releasedUnits) ||
+        typeof value.replayed !== 'boolean') {
+        return false;
+    }
+    return (value.actualUnits === expectedActualUnits &&
+        value.reservedUnits >= value.actualUnits &&
+        value.releasedUnits === value.reservedUnits - value.actualUnits);
+}
+function isVectorSettlementReplyForRequest(value, expectedActuals) {
+    if (!isRecord(value) || typeof value.replayed !== 'boolean' || !Array.isArray(value.dimensions)) {
+        return false;
+    }
+    if (value.dimensions.length !== expectedActuals.length)
+        return false;
+    const expected = new Map(expectedActuals.map(item => [item.id, item.actualUnits]));
+    const seen = new Set();
+    for (const raw of value.dimensions) {
+        if (!isRecord(raw) ||
+            !isExpectedHash(raw.id, expectedActuals.map(item => item.id)) ||
+            seen.has(raw.id) ||
+            !isNonNegativeInteger(raw.reservedUnits) ||
+            !isNonNegativeInteger(raw.actualUnits) ||
+            !isNonNegativeInteger(raw.releasedUnits)) {
+            return false;
+        }
+        const id = raw.id;
+        seen.add(id);
+        const actual = expected.get(id);
+        if (actual === undefined ||
+            raw.actualUnits !== actual ||
+            raw.reservedUnits < raw.actualUnits ||
+            raw.releasedUnits !== raw.reservedUnits - raw.actualUnits) {
+            return false;
+        }
+    }
+    return seen.size === expected.size;
+}
+function isExactBudgetBalances(value, expectedIds) {
+    if (!Array.isArray(value) || value.length !== expectedIds.length)
+        return false;
+    const expected = new Set(expectedIds);
+    const seen = new Set();
+    for (const raw of value) {
+        if (!isRecord(raw) ||
+            typeof raw.id !== 'string' ||
+            !expected.has(raw.id) ||
+            seen.has(raw.id) ||
+            !isNonNegativeInteger(raw.remaining)) {
+            return false;
+        }
+        seen.add(raw.id);
+    }
+    return seen.size === expected.size;
+}
+function isExactVectorBalances(value, dimensions) {
+    return isExactVectorBalancePairs(value, dimensions.flatMap(dimension => dimension.budgets.map(budget => [dimension.id, budget.id])));
+}
+function isExactVectorGrowthBalances(value, dimensions) {
+    return isExactVectorBalancePairs(value, dimensions.flatMap(dimension => dimension.budgets.map(budget => [dimension.id, budget.id])));
+}
+function isExactVectorBalancePairs(value, expectedPairs) {
+    if (!Array.isArray(value) || value.length !== expectedPairs.length)
+        return false;
+    const expected = new Set(expectedPairs.map(([dimensionId, budgetId]) => `${dimensionId}\u0000${budgetId}`));
+    const seen = new Set();
+    for (const raw of value) {
+        if (!isRecord(raw) ||
+            typeof raw.dimensionId !== 'string' ||
+            typeof raw.budgetId !== 'string' ||
+            !isNonNegativeInteger(raw.remaining)) {
+            return false;
+        }
+        const pair = `${raw.dimensionId}\u0000${raw.budgetId}`;
+        if (!expected.has(pair) || seen.has(pair))
+            return false;
+        seen.add(pair);
+    }
+    return seen.size === expected.size;
+}
+function reservedDimensionMap(value, expectedIds) {
+    if (!Array.isArray(value) || value.length !== expectedIds.length)
+        return undefined;
+    const expected = new Set(expectedIds);
+    const result = new Map();
+    for (const raw of value) {
+        if (!isRecord(raw) ||
+            typeof raw.id !== 'string' ||
+            !expected.has(raw.id) ||
+            result.has(raw.id) ||
+            !isNonNegativeInteger(raw.reservedUnits)) {
+            return undefined;
+        }
+        result.set(raw.id, raw.reservedUnits);
+    }
+    return result.size === expected.size ? result : undefined;
+}
+function isExpectedHash(value, expectedIds) {
+    return typeof value === 'string' && HASH_PATTERN.test(value) && expectedIds.includes(value);
+}
+function isExpectedDimensionId(value, dimensions) {
+    return typeof value === 'string' && dimensions.some(dimension => dimension.id === value);
+}
+function isExpectedVectorBudgetId(value, dimensions) {
+    return (typeof value === 'string' &&
+        dimensions.some(dimension => dimension.budgets.some(budget => budget.id === value)));
+}
+function isExpectedVectorPair(dimensionId, budgetId, dimensions) {
+    if (typeof dimensionId !== 'string' || typeof budgetId !== 'string')
+        return false;
+    const dimension = dimensions.find(item => item.id === dimensionId);
+    return dimension !== undefined && dimension.budgets.some(budget => budget.id === budgetId);
+}
+function isExpectedVectorGrowthPair(dimensionId, budgetId, dimensions) {
+    if (typeof dimensionId !== 'string' || typeof budgetId !== 'string')
+        return false;
+    const dimension = dimensions.find(item => item.id === dimensionId);
+    return dimension !== undefined && dimension.budgets.some(budget => budget.id === budgetId);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isRecoveryReport(value) {
+    if (!isRecord(value) || !isRecoverySummary(value.aggregate))
+        return false;
+    if (value.direct === undefined)
+        return true;
+    if (!isRecord(value.direct) ||
+        !isReservationId(value.direct.reservationId) ||
+        (value.direct.state !== 'pending' && value.direct.state !== 'liable')) {
+        return false;
+    }
+    if (value.direct.vector === true) {
+        return (isNonNegativeInteger(value.direct.dimensionCount) &&
+            isNonNegativeInteger(value.direct.budgetCount));
+    }
+    return isNonNegativeInteger(value.direct.reservedUnits);
+}
+function isRecoverySummary(value) {
+    return (isRecord(value) &&
+        isNonNegativeInteger(value.pendingCount) &&
+        isNonNegativeInteger(value.pendingUnits) &&
+        isNonNegativeInteger(value.liableCount) &&
+        isNonNegativeInteger(value.liableUnits) &&
+        (value.vectorPendingCount === undefined || isNonNegativeInteger(value.vectorPendingCount)) &&
+        (value.vectorLiableCount === undefined || isNonNegativeInteger(value.vectorLiableCount)));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isReservationId(value) {
+    return typeof value === 'string' && RESERVATION_ID_PATTERN.test(value);
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+function responseJson(value, status) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            'cache-control': 'no-store',
+        },
+    });
+}
+//# sourceMappingURL=index.js.map