@openlup/platform 0.26.0 → 0.27.0

package/dist/commerce/server/orderDraftRpcPayload.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { commerceIdempotencyKeySchema } from "../contractPrimitives.js";
+export const ORDER_DRAFT_RPC_NAME = "commerce_create_order_draft_with_outbox";
+export function createOrderDraftRpcPayload(input) {
+    const orderDraftRpcArgsSchema = z.object({
+        p_idempotency_key: commerceIdempotencyKeySchema,
+        p_quote_snapshot: input.quoteSchema,
+        p_order_draft_snapshot: input.draftSchema,
+        // Omit the optional client for anonymous calls, preserving the three-argument RPC.
+        p_client_id: z.guid().optional(),
+    }).strict();
+    function createOrderDraftRpcArgs(request, clientId = null) {
+        const base = {
+            p_idempotency_key: request.idempotencyKey,
+            p_quote_snapshot: request.quoteSnapshot,
+            p_order_draft_snapshot: input.createSnapshot(request.quoteSnapshot),
+        };
+        return orderDraftRpcArgsSchema.parse(clientId ? { ...base, p_client_id: clientId } : base);
+    }
+    return { orderDraftRpcArgsSchema, createOrderDraftRpcArgs };
+}

package/dist/commerce/server/orderFeedbackSubmit.d.ts

@@ -0,0 +1,20 @@
+import { ORDER_FEEDBACK_SUBMIT_RPC_NAME, type OrderFeedbackSubmitRequest } from "../orderFeedbackContracts.js";
+interface RpcError {
+    message?: string;
+}
+export interface OrderFeedbackSubmitRpcClient {
+    rpc(functionName: typeof ORDER_FEEDBACK_SUBMIT_RPC_NAME, args: {
+        p_token: string;
+        p_rating: number;
+        p_comment: string | null;
+    }): PromiseLike<{
+        data: unknown;
+        error: RpcError | null;
+    }>;
+}
+export interface OrderFeedbackSubmitPort {
+    submit(request: OrderFeedbackSubmitRequest): Promise<unknown>;
+}
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export declare function createSupabaseOrderFeedbackSubmitPort(client: OrderFeedbackSubmitRpcClient): OrderFeedbackSubmitPort;
+export {};

package/dist/commerce/server/orderFeedbackSubmit.js

@@ -0,0 +1,16 @@
+import { ORDER_FEEDBACK_SUBMIT_RPC_NAME, } from "../orderFeedbackContracts.js";
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export function createSupabaseOrderFeedbackSubmitPort(client) {
+    return {
+        async submit(request) {
+            const { data, error } = await client.rpc(ORDER_FEEDBACK_SUBMIT_RPC_NAME, {
+                p_token: request.token,
+                p_rating: request.rating,
+                p_comment: request.comment ?? null,
+            });
+            if (error)
+                throw new Error(error.message ?? "order_feedback_submit_failed");
+            return data;
+        },
+    };
+}

package/dist/commerce/server/orderFeedbackTokenCheck.d.ts

@@ -0,0 +1,17 @@
+import { ORDER_FEEDBACK_CHECK_RPC_NAME, type OrderFeedbackTokenCheckRequest } from "../orderFeedbackContracts.js";
+interface RpcError {
+    message?: string;
+}
+export interface OrderFeedbackTokenCheckRpcClient {
+    rpc(functionName: typeof ORDER_FEEDBACK_CHECK_RPC_NAME, args: {
+        p_token: string;
+    }): PromiseLike<{
+        data: unknown;
+        error: RpcError | null;
+    }>;
+}
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export declare function createSupabaseOrderFeedbackTokenCheckPort(client: OrderFeedbackTokenCheckRpcClient): {
+    check(request: OrderFeedbackTokenCheckRequest): Promise<unknown>;
+};
+export {};

package/dist/commerce/server/orderFeedbackTokenCheck.js

@@ -0,0 +1,14 @@
+import { ORDER_FEEDBACK_CHECK_RPC_NAME, } from "../orderFeedbackContracts.js";
+/** Hosted token feedback only; the adopter must provide this RPC. Native db/platform has no binding. */
+export function createSupabaseOrderFeedbackTokenCheckPort(client) {
+    return {
+        async check(request) {
+            const { data, error } = await client.rpc(ORDER_FEEDBACK_CHECK_RPC_NAME, {
+                p_token: request.token,
+            });
+            if (error)
+                throw new Error(error.message ?? "order_feedback_token_check_failed");
+            return data;
+        },
+    };
+}

package/dist/commerce/server/orderReviewAdminHandlers.d.ts

@@ -0,0 +1,47 @@
+import { type OrderReviewFailure } from "../orderReviewContracts.js";
+import type { OrderReviewAdminReadPort, OrderReviewLifecyclePort } from "../orderReviewPorts.js";
+type Result<T> = {
+    ok: true;
+    value: T;
+    replayed?: boolean;
+} | {
+    ok: false;
+    error: OrderReviewFailure;
+};
+/** Actor identity is supplied only by the already-authorized route composition. */
+export declare function createOrderReviewAdminHandlers(lifecycle: OrderReviewLifecyclePort, readPort: OrderReviewAdminReadPort): {
+    list(actorRef: string, input: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<Result<Awaited<ReturnType<OrderReviewAdminReadPort["list"]>>>>;
+    read(actorRef: string, reviewRef: string): Promise<Result<Awaited<ReturnType<OrderReviewAdminReadPort["read"]>>>>;
+    moderate(actorRef: string, input: unknown): Promise<{
+        ok: false;
+        error: OrderReviewFailure;
+    } | {
+        ok: true;
+        value: {
+            contractVersion: "commerce.order-review.v1";
+            reviewRef: string;
+            rating: number;
+            comment: string | null;
+            moderation: "pending" | "visible" | "hidden";
+            createdAt: string;
+        };
+        replayed: boolean | undefined;
+    }>;
+    revoke(actorRef: string, input: {
+        reviewRef?: string;
+        idempotencyKey?: string;
+    }): Promise<{
+        ok: false;
+        error: OrderReviewFailure;
+    } | {
+        ok: true;
+        value: {
+            replayed: boolean;
+        };
+        replayed: boolean | undefined;
+    }>;
+};
+export {};

package/dist/commerce/server/orderReviewAdminHandlers.js

@@ -0,0 +1,41 @@
+import { orderReviewAdminRevokeSchema, orderReviewReferenceSchema, orderReviewModerationSchema, } from "../orderReviewContracts.js";
+import { runOrderReviewCommand } from "./orderReviewHandlers.js";
+/** Actor identity is supplied only by the already-authorized route composition. */
+export function createOrderReviewAdminHandlers(lifecycle, readPort) {
+    return {
+        async list(actorRef, input) {
+            if (!validActor(actorRef))
+                return unavailable();
+            const limit = Math.min(Math.max(input.limit ?? 25, 1), 100);
+            try {
+                return { ok: true, value: await readPort.list({ actorRef, cursor: input.cursor, limit }) };
+            }
+            catch {
+                return unavailable();
+            }
+        },
+        async read(actorRef, reviewRef) {
+            if (!validActor(actorRef) || !orderReviewReferenceSchema.safeParse(reviewRef).success)
+                return unavailable();
+            try {
+                const review = await readPort.read({ actorRef, reviewRef });
+                return review ? { ok: true, value: review } : unavailable();
+            }
+            catch {
+                return unavailable();
+            }
+        },
+        async moderate(actorRef, input) {
+            if (!validActor(actorRef))
+                return unavailable();
+            return runOrderReviewCommand(orderReviewModerationSchema.safeParse(input), (data) => lifecycle.moderate({ ...data, actorRef }), (result) => result.value);
+        },
+        async revoke(actorRef, input) {
+            if (!validActor(actorRef))
+                return unavailable();
+            return runOrderReviewCommand(orderReviewAdminRevokeSchema.safeParse(input), (data) => lifecycle.revoke({ ...data, actorRef }), (result) => result);
+        },
+    };
+}
+function validActor(value) { return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(value); }
+function unavailable() { return { ok: false, error: { kind: "unavailable" } }; }

package/dist/commerce/server/orderReviewHandlers.d.ts

@@ -0,0 +1,114 @@
+import { type OrderReviewFailure, type OrderReviewReadResult } from "../orderReviewContracts.js";
+import type { OrderReviewLifecyclePort } from "../orderReviewPorts.js";
+type Result<T> = {
+    ok: true;
+    value: T;
+    replayed?: boolean;
+} | {
+    ok: false;
+    error: OrderReviewFailure;
+};
+/** HTTP-neutral customer orchestration; route composition owns bearer extraction. */
+export declare function createOrderReviewHandlers(port: OrderReviewLifecyclePort): {
+    read(grant: string): Promise<Result<OrderReviewReadResult>>;
+    submit(input: unknown): Promise<{
+        ok: false;
+        error: OrderReviewFailure;
+    } | {
+        ok: true;
+        value: {
+            contractVersion: "commerce.order-review.v1";
+            reviewRef: string;
+            rating: number;
+            comment: string | null;
+            moderation: "pending" | "visible" | "hidden";
+            createdAt: string;
+        };
+        replayed: boolean | undefined;
+    }>;
+    createMediaIntent(input: unknown): Promise<{
+        ok: false;
+        error: OrderReviewFailure;
+    } | {
+        ok: true;
+        value: {
+            media: {
+                state: "pending";
+                observedContentType: null;
+                observedByteLength: null;
+                observedDigest: null;
+                mediaRef: string;
+                declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+                declaredByteLength: number;
+            } | {
+                state: "stored" | "confirmed";
+                observedContentType: "image/png" | "image/jpeg" | "image/webp";
+                observedByteLength: number;
+                observedDigest: string;
+                mediaRef: string;
+                declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+                declaredByteLength: number;
+            } | {
+                state: "cleanup_pending" | "deleted";
+                observedContentType: "image/png" | "image/jpeg" | "image/webp" | null;
+                observedByteLength: number | null;
+                observedDigest: string | null;
+                mediaRef: string;
+                declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+                declaredByteLength: number;
+            };
+            uploadExpiresAt: string;
+            replayed: boolean;
+        };
+        replayed: boolean | undefined;
+    }>;
+    confirmMedia(input: unknown): Promise<{
+        ok: false;
+        error: OrderReviewFailure;
+    } | {
+        ok: true;
+        value: {
+            state: "pending";
+            observedContentType: null;
+            observedByteLength: null;
+            observedDigest: null;
+            mediaRef: string;
+            declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+            declaredByteLength: number;
+        } | {
+            state: "stored" | "confirmed";
+            observedContentType: "image/png" | "image/jpeg" | "image/webp";
+            observedByteLength: number;
+            observedDigest: string;
+            mediaRef: string;
+            declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+            declaredByteLength: number;
+        } | {
+            state: "cleanup_pending" | "deleted";
+            observedContentType: "image/png" | "image/jpeg" | "image/webp" | null;
+            observedByteLength: number | null;
+            observedDigest: string | null;
+            mediaRef: string;
+            declaredContentType: "image/png" | "image/jpeg" | "image/webp";
+            declaredByteLength: number;
+        };
+        replayed: boolean | undefined;
+    }>;
+};
+/** Shared command scaffold: parse result, one port call, the value mapper, failure mapping. */
+export declare function runOrderReviewCommand<D, R extends {
+    replayed?: boolean;
+}, V>(parsed: {
+    success: true;
+    data: D;
+} | {
+    success: false;
+}, call: (data: D) => Promise<R>, map: (result: R) => V): Promise<{
+    ok: false;
+    error: OrderReviewFailure;
+} | {
+    ok: true;
+    value: V;
+    replayed: boolean | undefined;
+}>;
+export {};

package/dist/commerce/server/orderReviewHandlers.js

@@ -0,0 +1,42 @@
+import { orderReviewFailure, orderReviewMediaConfirmSchema, orderReviewMediaIntentSchema, orderReviewSubmitSchema, } from "../orderReviewContracts.js";
+/** HTTP-neutral customer orchestration; route composition owns bearer extraction. */
+export function createOrderReviewHandlers(port) {
+    return {
+        async read(grant) {
+            try {
+                const result = await port.read(grant);
+                return result ? { ok: true, value: result } : { ok: false, error: { kind: "unavailable" } };
+            }
+            catch (error) {
+                return { ok: false, error: orderReviewFailure(errorCode(error)) };
+            }
+        },
+        async submit(input) {
+            return runOrderReviewCommand(orderReviewSubmitSchema.safeParse(input), (data) => port.submit(data), (result) => result.value);
+        },
+        async createMediaIntent(input) {
+            return runOrderReviewCommand(orderReviewMediaIntentSchema.safeParse(input), (data) => port.createMediaIntent(data), (result) => result);
+        },
+        async confirmMedia(input) {
+            return runOrderReviewCommand(orderReviewMediaConfirmSchema.safeParse(input), (data) => port.confirmMedia(data), (result) => result.value);
+        },
+    };
+}
+/** Shared command scaffold: parse result, one port call, the value mapper, failure mapping. */
+export async function runOrderReviewCommand(parsed, call, map) {
+    if (parsed.success === false)
+        return invalid();
+    try {
+        const result = await call(parsed.data);
+        return { ok: true, value: map(result), replayed: result.replayed };
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function invalid() { return { ok: false, error: { kind: "invalid" } }; }
+function failure(error) { return { ok: false, error: orderReviewFailure(errorCode(error)) }; }
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code : undefined;
+}

package/dist/commerce/server/orderReviewLifecycle.d.ts

@@ -0,0 +1,10 @@
+import type { OrderReviewAdminReadPort, OrderReviewLifecyclePort } from "../orderReviewPorts.js";
+type PgQueryExecutor = {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+};
+export declare function createPostgresOrderReviewLifecyclePort(executor: PgQueryExecutor): OrderReviewLifecyclePort;
+/** Admin route composition authenticates the actor before invoking this adapter. */
+export declare function createPostgresOrderReviewAdminReadPort(executor: PgQueryExecutor): OrderReviewAdminReadPort;
+export {};

package/dist/commerce/server/orderReviewLifecycle.js

@@ -0,0 +1,121 @@
+import { ORDER_REVIEW_CONTRACT_VERSION, orderReviewAdminDetailSchema, orderReviewMediaSchema, orderReviewMediaIntentResultSchema, orderReviewReadResultSchema, orderReviewSchema, } from "../orderReviewContracts.js";
+const READ = "SELECT public.order_review_read($1::text, now()) AS response";
+const SUBMIT = "SELECT public.order_review_submit($1::text,$2::integer,$3::text,$4::text,now()) AS response";
+const INTENT = "SELECT public.order_review_create_media_intent($1::text,$2::text,$3::integer,$4::text,$5::text,now()) AS response";
+const CONFIRM = "SELECT public.order_review_confirm_media($1::text,$2::text,$3::text,$4::text,now()) AS response";
+const MODERATE = "SELECT public.order_review_moderate($1::text,$2::text,$3::text,$4::text,now()) AS response";
+const REVOKE = "SELECT public.order_review_revoke_access($1::text,$2::text,$3::text,now()) AS response";
+const ADMIN_LIST = "SELECT public.order_review_admin_list($1::text,$2::text,$3::integer,now()) AS response";
+const ADMIN_READ = "SELECT public.order_review_admin_read($1::text,$2::text,now()) AS response";
+export function createPostgresOrderReviewLifecyclePort(executor) {
+    return {
+        async read(grant) {
+            const response = await call(executor, READ, [grant]);
+            if (response === null)
+                return null;
+            return readResult(response);
+        },
+        async submit(input) {
+            return replay(review(required(await call(executor, SUBMIT, [input.grant, input.rating, input.comment ?? null, input.fingerprint]))));
+        },
+        async createMediaIntent(input) {
+            return mediaIntent(required(await call(executor, INTENT, [
+                input.grant, input.contentType, input.byteLength, input.capabilityDigest, input.commandKey,
+            ])));
+        },
+        async confirmMedia(input) {
+            return replay(media(required(await call(executor, CONFIRM, [input.grant, input.mediaRef, input.digest, input.commandKey]))));
+        },
+        async moderate(input) {
+            return replay(review(await call(executor, MODERATE, [
+                input.reviewRef, input.action, input.actorRef, input.idempotencyKey,
+            ])));
+        },
+        async revoke(input) {
+            const response = object(await call(executor, REVOKE, [input.reviewRef, input.actorRef, input.idempotencyKey]));
+            if (!response)
+                throw invalid();
+            return { replayed: response.replayed === true };
+        },
+    };
+}
+/** Admin route composition authenticates the actor before invoking this adapter. */
+export function createPostgresOrderReviewAdminReadPort(executor) {
+    return {
+        async list(input) {
+            const row = object(await call(executor, ADMIN_LIST, [input.actorRef, input.cursor ?? null, input.limit]));
+            if (!row || !Array.isArray(row.items))
+                throw invalid();
+            const items = row.items.map((item) => review(item));
+            const nextCursor = row.nextCursor;
+            if (nextCursor !== undefined && typeof nextCursor !== "string")
+                throw invalid();
+            return nextCursor === undefined ? { items } : { items, nextCursor: nextCursor };
+        },
+        async read(input) {
+            const response = await call(executor, ADMIN_READ, [input.actorRef, input.reviewRef]);
+            return response === null ? null : adminDetail(response);
+        },
+    };
+}
+async function call(executor, sql, values) {
+    const result = await executor.query(sql, values);
+    return object(result.rows[0])?.response ?? null;
+}
+function replay(value) {
+    const { replayed, ...result } = value;
+    return { value: result, replayed: replayed === true };
+}
+function review(value) {
+    const row = object(value);
+    if (!row)
+        throw invalid();
+    const { replayed, ...payload } = row;
+    const parsed = orderReviewSchema.parse({
+        contractVersion: payload.contractVersion ?? ORDER_REVIEW_CONTRACT_VERSION,
+        ...payload,
+        comment: payload.comment ?? null,
+    });
+    return { ...parsed, ...(typeof replayed === "boolean" ? { replayed } : {}) };
+}
+function media(value) {
+    const row = object(value);
+    if (!row)
+        throw invalid();
+    const { replayed, ...payload } = row;
+    const parsed = orderReviewMediaSchema.parse(payload);
+    return { ...parsed, ...(typeof replayed === "boolean" ? { replayed } : {}) };
+}
+function mediaIntent(value) {
+    const row = object(value);
+    if (!row)
+        throw invalid();
+    return orderReviewMediaIntentResultSchema.parse(row);
+}
+function readResult(value) {
+    const row = object(value);
+    if (!row || !Array.isArray(row.media))
+        throw invalid();
+    return orderReviewReadResultSchema.parse({
+        review: row.review === null ? null : review(row.review),
+        media: row.media.map((item) => media(item)),
+    });
+}
+function adminDetail(value) {
+    const row = object(value);
+    if (!row || !Array.isArray(row.media))
+        throw invalid();
+    return orderReviewAdminDetailSchema.parse({
+        review: review(row.review),
+        media: row.media.map((item) => media(item)),
+    });
+}
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function invalid() { return Object.assign(new Error("order_review_response_invalid"), { code: "order_review_invalid" }); }
+function required(value) {
+    if (value === null)
+        throw Object.assign(new Error("order_review_unavailable"), { code: "order_review_unavailable" });
+    return value;
+}

package/dist/commerce/server/orderReviewMedia.d.ts

@@ -0,0 +1,11 @@
+import type { OrderReviewMediaPort } from "../orderReviewPorts.js";
+type PgQueryExecutor = {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+};
+export interface OrderReviewMediaTransactionLane {
+    run<T>(work: (executor: PgQueryExecutor) => Promise<T>): Promise<T>;
+}
+export declare function createPostgresOrderReviewMediaPort(executor: PgQueryExecutor, transactionLane?: OrderReviewMediaTransactionLane): OrderReviewMediaPort;
+export {};

package/dist/commerce/server/orderReviewMedia.js

@@ -0,0 +1,172 @@
+import { orderReviewMediaSchema, } from "../orderReviewContracts.js";
+const READ = "SELECT public.order_review_read_media($1::text,$2::text,now()) AS response";
+const ADMIT = "SELECT public.order_review_admit_media_upload($1::text,$2::text,$3::integer,$4::text,now()) AS response";
+const LOCK_FINALIZE = "SELECT public.order_review_lock_media_finalize($1::text,$2::text,$3::bigint,now()) AS response";
+const STORED = "SELECT public.order_review_record_media_stored($1::text,$2::text,$3::bigint,$4::text,$5::integer,now()) AS response";
+const ABORT = "SELECT public.order_review_abort_media_upload($1::text,$2::text,$3::bigint,$4::text,now()) AS response";
+const ADMIN_READ = "SELECT public.order_review_admin_read_media($1::text,$2::text) AS response";
+const ADMIN_DELETE_PREPARE = "SELECT public.order_review_admin_prepare_media_delete($1::text,$2::text,$3::text,now()) AS response";
+const ADMIN_DELETE_COMPLETE = "SELECT public.order_review_admin_complete_media_delete($1::text,$2::text,now()) AS response";
+const CLAIM_RECONCILE = "SELECT public.order_review_claim_media_reconcile($1::integer,now()) AS response";
+const COMPLETE_RECONCILE = "SELECT public.order_review_complete_media_reconcile($1::text,$2::text,$3::text,$4::integer,$5::text,$6::text,now()) AS response";
+export function createPostgresOrderReviewMediaPort(executor, transactionLane) {
+    return {
+        async readAuthorized(grant, mediaRef) { return mediaObjectOrNull(await call(executor, READ, [grant, mediaRef])); },
+        async admitUpload(input) {
+            let value;
+            try {
+                value = object(await call(executor, ADMIT, [
+                    input.capabilityDigest, input.declaredContentType, input.declaredByteLength, input.writerRef,
+                ]));
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+                if (code === "23505" || code === "order_review_conflict")
+                    return { kind: "conflict" };
+                throw error;
+            }
+            if (!value)
+                return { kind: "unavailable" };
+            if (value.kind === "complete")
+                return { kind: "complete", media: media(value.media) };
+            if (value.kind !== undefined && value.kind !== "lease")
+                throw invalid();
+            const parsed = media(value.media);
+            const leaseVersion = value.leaseVersion;
+            const leaseExpiresAt = value.leaseExpiresAt;
+            const objectKey = value.objectKey;
+            const declaredContentType = value.declaredContentType;
+            const declaredByteLength = value.declaredByteLength;
+            if (!Number.isInteger(leaseVersion) || typeof leaseExpiresAt !== "string" || typeof objectKey !== "string"
+                || (declaredContentType !== "image/jpeg" && declaredContentType !== "image/png" && declaredContentType !== "image/webp")
+                || !Number.isInteger(declaredByteLength))
+                throw invalid();
+            return { kind: "lease", reservation: { media: parsed, leaseVersion: leaseVersion, leaseExpiresAt, objectKey,
+                    declaredContentType, declaredByteLength: declaredByteLength } };
+        },
+        async finalizeUpload(input) {
+            if (!transactionLane)
+                throw Object.assign(new Error("order_review_finalize_lane_required"), { code: "order_review_invalid" });
+            let leased = false;
+            try {
+                return await transactionLane.run(async (transaction) => {
+                    const locked = await call(transaction, LOCK_FINALIZE, [input.capabilityDigest, input.writerRef, input.leaseVersion]);
+                    if (locked === null)
+                        return null;
+                    const lockedRow = object(locked);
+                    if (!lockedRow || !lockedRow.media)
+                        throw invalid();
+                    media(lockedRow.media);
+                    leased = true;
+                    await input.promote();
+                    const stored = mediaOrNull(await call(transaction, STORED, [
+                        input.capabilityDigest, input.writerRef, input.leaseVersion, input.digest, input.byteLength,
+                    ]));
+                    if (!stored)
+                        throw invalid();
+                    return stored;
+                });
+            }
+            catch (error) {
+                // The transaction has rolled back: persist cleanup_pending outside it.
+                if (leased)
+                    await call(executor, ABORT, [input.capabilityDigest, input.writerRef, input.leaseVersion, "finalize_failed"]);
+                throw error;
+            }
+        },
+        async abortUpload(input) { await call(executor, ABORT, [input.capabilityDigest, input.writerRef, input.leaseVersion, input.reason]); },
+        async readAdmin(input) { return mediaObjectOrNull(await call(executor, ADMIN_READ, [input.actorRef, input.mediaRef])); },
+        async prepareAdminDelete(input) {
+            const value = object(await call(executor, ADMIN_DELETE_PREPARE, [input.actorRef, input.mediaRef, input.idempotencyKey]));
+            if (!value)
+                return null;
+            return cleanup(value);
+        },
+        async completeAdminDelete(input) {
+            const value = object(await call(executor, ADMIN_DELETE_COMPLETE, [input.actorRef, input.cleanupReceipt]));
+            if (!value)
+                throw invalid();
+            return { replayed: value.replayed === true };
+        },
+        async claimReconcile(limit) {
+            if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+                throw invalid();
+            const value = object(await call(executor, CLAIM_RECONCILE, [limit]));
+            if (!value || !Array.isArray(value.tasks))
+                throw invalid();
+            return value.tasks.map(reconcileTask);
+        },
+        async completeReconcile(input) {
+            const outcome = input.outcome;
+            if (!/^[-A-Za-z0-9_:]{1,512}$/.test(input.receipt))
+                throw invalid();
+            if (outcome.kind === "stored" && (!Number.isInteger(outcome.observedByteLength)
+                || outcome.observedByteLength < 1 || outcome.observedByteLength > 20 * 1024 * 1024
+                || !/^[a-f0-9]{64}$/.test(outcome.observedDigest)))
+                throw invalid();
+            if (outcome.kind === "retry" && (outcome.reason.length < 1 || outcome.reason.length > 128))
+                throw invalid();
+            await call(executor, COMPLETE_RECONCILE, [
+                input.receipt,
+                outcome.kind,
+                outcome.kind === "stored" ? outcome.observedContentType : null,
+                outcome.kind === "stored" ? outcome.observedByteLength : null,
+                outcome.kind === "stored" ? outcome.observedDigest : null,
+                outcome.kind === "retry" ? outcome.reason : null,
+            ]);
+        },
+    };
+}
+async function call(executor, sql, values) {
+    const result = await executor.query(sql, values);
+    return object(result.rows[0])?.response ?? null;
+}
+function mediaOrNull(value) {
+    return value === null ? null : media(value);
+}
+function media(value) { return orderReviewMediaSchema.parse(value); }
+function mediaObjectOrNull(value) {
+    if (value === null)
+        return null;
+    const row = object(value);
+    if (!row || typeof row.objectKey !== "string")
+        throw invalid();
+    return { media: media(row.media), objectKey: row.objectKey };
+}
+function cleanup(value) {
+    if (typeof value.objectKey !== "string" || typeof value.cleanupReceipt !== "string" || typeof value.replayed !== "boolean")
+        throw invalid();
+    if (value.tempKey !== undefined && value.tempKey !== null && typeof value.tempKey !== "string")
+        throw invalid();
+    return { media: media(value.media), objectKey: value.objectKey,
+        ...(typeof value.tempKey === "string" ? { tempKey: value.tempKey } : {}),
+        cleanupReceipt: value.cleanupReceipt, replayed: value.replayed };
+}
+function reconcileTask(value) {
+    const row = object(value);
+    const expectedDeclaredByteLength = row?.expectedDeclaredByteLength;
+    const tempKey = row?.tempKey;
+    if (!row
+        || typeof row.receipt !== "string"
+        || (row.kind !== "finalize" && row.kind !== "delete")
+        || typeof row.objectKey !== "string"
+        || (tempKey !== undefined && typeof tempKey !== "string")
+        || (row.expectedDeclaredContentType !== "image/jpeg" && row.expectedDeclaredContentType !== "image/png" && row.expectedDeclaredContentType !== "image/webp")
+        || !Number.isInteger(expectedDeclaredByteLength)
+        || typeof expectedDeclaredByteLength !== "number"
+        || expectedDeclaredByteLength < 1
+        || expectedDeclaredByteLength > 20 * 1024 * 1024)
+        throw invalid();
+    return {
+        receipt: row.receipt,
+        kind: row.kind,
+        objectKey: row.objectKey,
+        ...(tempKey === undefined ? {} : { tempKey: tempKey }),
+        expectedDeclaredContentType: row.expectedDeclaredContentType,
+        expectedDeclaredByteLength,
+    };
+}
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function invalid() { return Object.assign(new Error("order_review_media_response_invalid"), { code: "order_review_invalid" }); }