@lumenkey/cli 0.3.0 → 0.4.0-rc.1

package/dist/studio/output-save-service.d.ts

@@ -0,0 +1,436 @@
+import type { LumenKeyConfig } from '../core/types.js';
+import type { StudioAssetStore } from './asset-store.js';
+import { type SaveOperation } from './output-save-contract.js';
+type SaveProgress = {
+    receivedBytes: number;
+    totalBytes: number | null;
+};
+export declare function saveHttpError(error: unknown, bind?: boolean): {
+    status: number;
+    body: {
+        error: {
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            resumeDeadline?: string | undefined;
+            recovery?: import("../core/locale.js").UnknownRecovery | undefined;
+            submission?: import("../index.js").Submission | undefined;
+            httpStatus?: number | undefined;
+            code: string;
+            message: string;
+            type: string;
+        };
+        root?: null | undefined;
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        } | null;
+        save: {
+            progress: SaveProgress | null;
+            error: {
+                code: string;
+                message: string;
+                type: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                httpStatus?: number | undefined;
+            } | null;
+            createdAt: string;
+            state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+            jobId: string;
+            updatedAt: string;
+            revision: number;
+            runId: string;
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+            attempt: number;
+            facts: {
+                file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+            };
+            asset: {
+                sha256: string;
+                byteLength: number;
+                assetId: string;
+                displayName: string;
+                mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                relativePath: string;
+                absolutePath: string;
+                contentUrl: string;
+            } | null;
+            safeRetry: boolean;
+            checkedAt: string | null;
+            integrityCheck: "PENDING" | "IDLE";
+            operationId: string;
+            localOutputId: string;
+            gatewayAssetId: string;
+        } | null;
+    };
+};
+interface SaveWorker {
+    enqueue(operationId: string): void;
+    retry?(id: string, connectionId: string, revision: number): Promise<SaveOperation>;
+    suspend?(connectionId: string): void;
+    activate?(connectionId: string): void;
+    recover?(): Promise<void>;
+    progress?(id: string, revision: number, attempt: number): SaveProgress | null;
+}
+export declare function createOutputSaveService(options: {
+    store?: StudioAssetStore;
+    outputDir?: string;
+    loadConfig(): LumenKeyConfig | Promise<LumenKeyConfig>;
+    worker?: SaveWorker;
+    makeWorker?(): SaveWorker;
+}): {
+    invalidate: () => void;
+    localScope: () => {
+        rootId: string | null;
+        connectionId: string;
+    } | null;
+    preflight: (bind?: boolean) => Promise<void>;
+    bind: () => Promise<{
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        root: {
+            absolutePath: string;
+        } | null;
+        code: string | null;
+    }>;
+    outputs: (runId: string) => Promise<{
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        revision: number;
+        items: {
+            save: {
+                progress: SaveProgress | null;
+                error: {
+                    code: string;
+                    message: string;
+                    type: string;
+                    retryable: boolean;
+                    mayAlreadyBeSaved: boolean | null;
+                    httpStatus?: number | undefined;
+                } | null;
+                createdAt: string;
+                state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+                jobId: string;
+                updatedAt: string;
+                revision: number;
+                runId: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+                attempt: number;
+                facts: {
+                    file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                    registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                    relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+                };
+                asset: {
+                    sha256: string;
+                    byteLength: number;
+                    assetId: string;
+                    displayName: string;
+                    mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                    relativePath: string;
+                    absolutePath: string;
+                    contentUrl: string;
+                } | null;
+                safeRetry: boolean;
+                checkedAt: string | null;
+                integrityCheck: "PENDING" | "IDLE";
+                operationId: string;
+                localOutputId: string;
+                gatewayAssetId: string;
+            } | null;
+            acceptance: "ACCEPTED" | "UNKNOWN" | "NEVER_ACCEPTED";
+            saveAllowed: boolean;
+            saveBlockedCode: string | null;
+            saveOperationId: string | null;
+            localOutputId: string | null;
+            runId: string;
+            jobId: string;
+            gatewayAssetId: string | null;
+            outputIndex: number | null;
+            displayOrdinal: number;
+            outputType: string | null;
+            mediaType: null;
+            identity: {
+                status: "UNVERIFIED";
+                reason: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT";
+            } | {
+                status: "VERIFIED";
+                reason: null;
+            };
+        }[];
+    }>;
+    output: (runId: string, localOutputId: string) => Promise<{
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        revision: number;
+        output: {
+            save: {
+                progress: SaveProgress | null;
+                error: {
+                    code: string;
+                    message: string;
+                    type: string;
+                    retryable: boolean;
+                    mayAlreadyBeSaved: boolean | null;
+                    httpStatus?: number | undefined;
+                } | null;
+                createdAt: string;
+                state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+                jobId: string;
+                updatedAt: string;
+                revision: number;
+                runId: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+                attempt: number;
+                facts: {
+                    file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                    registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                    relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+                };
+                asset: {
+                    sha256: string;
+                    byteLength: number;
+                    assetId: string;
+                    displayName: string;
+                    mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                    relativePath: string;
+                    absolutePath: string;
+                    contentUrl: string;
+                } | null;
+                safeRetry: boolean;
+                checkedAt: string | null;
+                integrityCheck: "PENDING" | "IDLE";
+                operationId: string;
+                localOutputId: string;
+                gatewayAssetId: string;
+            } | null;
+            acceptance: "ACCEPTED" | "UNKNOWN" | "NEVER_ACCEPTED";
+            saveAllowed: boolean;
+            saveBlockedCode: string | null;
+            saveOperationId: string | null;
+            localOutputId: string | null;
+            runId: string;
+            jobId: string;
+            gatewayAssetId: string | null;
+            outputIndex: number | null;
+            displayOrdinal: number;
+            outputType: string | null;
+            mediaType: null;
+            identity: {
+                status: "UNVERIFIED";
+                reason: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT";
+            } | {
+                status: "VERIFIED";
+                reason: null;
+            };
+        };
+        acceptance: "ACCEPTED" | "UNKNOWN" | "NEVER_ACCEPTED";
+        save: {
+            progress: SaveProgress | null;
+            error: {
+                code: string;
+                message: string;
+                type: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                httpStatus?: number | undefined;
+            } | null;
+            createdAt: string;
+            state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+            jobId: string;
+            updatedAt: string;
+            revision: number;
+            runId: string;
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+            attempt: number;
+            facts: {
+                file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+            };
+            asset: {
+                sha256: string;
+                byteLength: number;
+                assetId: string;
+                displayName: string;
+                mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                relativePath: string;
+                absolutePath: string;
+                contentUrl: string;
+            } | null;
+            safeRetry: boolean;
+            checkedAt: string | null;
+            integrityCheck: "PENDING" | "IDLE";
+            operationId: string;
+            localOutputId: string;
+            gatewayAssetId: string;
+        } | null;
+    }>;
+    accept: (runId: string, localOutputId: string, body: unknown) => Promise<{
+        status: number;
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        revision: number;
+        save: {
+            progress: SaveProgress | null;
+            error: {
+                code: string;
+                message: string;
+                type: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                httpStatus?: number | undefined;
+            } | null;
+            createdAt: string;
+            state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+            jobId: string;
+            updatedAt: string;
+            revision: number;
+            runId: string;
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+            attempt: number;
+            facts: {
+                file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+            };
+            asset: {
+                sha256: string;
+                byteLength: number;
+                assetId: string;
+                displayName: string;
+                mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                relativePath: string;
+                absolutePath: string;
+                contentUrl: string;
+            } | null;
+            safeRetry: boolean;
+            checkedAt: string | null;
+            integrityCheck: "PENDING" | "IDLE";
+            operationId: string;
+            localOutputId: string;
+            gatewayAssetId: string;
+        };
+    }>;
+    read: (id: string) => Promise<{
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        revision: number;
+        save: {
+            progress: SaveProgress | null;
+            error: {
+                code: string;
+                message: string;
+                type: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                httpStatus?: number | undefined;
+            } | null;
+            createdAt: string;
+            state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+            jobId: string;
+            updatedAt: string;
+            revision: number;
+            runId: string;
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+            attempt: number;
+            facts: {
+                file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+            };
+            asset: {
+                sha256: string;
+                byteLength: number;
+                assetId: string;
+                displayName: string;
+                mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                relativePath: string;
+                absolutePath: string;
+                contentUrl: string;
+            } | null;
+            safeRetry: boolean;
+            checkedAt: string | null;
+            integrityCheck: "PENDING" | "IDLE";
+            operationId: string;
+            localOutputId: string;
+            gatewayAssetId: string;
+        };
+    }>;
+    retry: (id: string, body: unknown) => Promise<{
+        status: number;
+        scope: {
+            rootId: string | null;
+            connectionId: string;
+        };
+        revision: number;
+        save: {
+            progress: SaveProgress | null;
+            error: {
+                code: string;
+                message: string;
+                type: string;
+                retryable: boolean;
+                mayAlreadyBeSaved: boolean | null;
+                httpStatus?: number | undefined;
+            } | null;
+            createdAt: string;
+            state: "ACCEPTED" | "SAVING" | "SAVED" | "FAILED" | "RECOVERY_REQUIRED" | "BLOCKED";
+            jobId: string;
+            updatedAt: string;
+            revision: number;
+            runId: string;
+            retryable: boolean;
+            mayAlreadyBeSaved: boolean | null;
+            stage: "QUEUED" | "DOWNLOADING" | "FILE_READY" | "REGISTERED" | "LINKED" | "RECONCILING";
+            attempt: number;
+            facts: {
+                file: "MISSING" | "NOT_CHECKED" | "ABSENT" | "PARTIAL" | "UNSAFE" | "UNKNOWN" | "VERIFIED" | "MODIFIED";
+                registration: "ABSENT" | "UNKNOWN" | "PRESENT";
+                relation: "ABSENT" | "UNKNOWN" | "PRESENT";
+            };
+            asset: {
+                sha256: string;
+                byteLength: number;
+                assetId: string;
+                displayName: string;
+                mediaType: "image/png" | "image/jpeg" | "image/webp" | "video/mp4" | "video/webm";
+                relativePath: string;
+                absolutePath: string;
+                contentUrl: string;
+            } | null;
+            safeRetry: boolean;
+            checkedAt: string | null;
+            integrityCheck: "PENDING" | "IDLE";
+            operationId: string;
+            localOutputId: string;
+            gatewayAssetId: string;
+        };
+    }>;
+};
+export {};
+//# sourceMappingURL=output-save-service.d.ts.map

package/dist/studio/output-save-service.js

@@ -0,0 +1,251 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { LumenKeyClient, LumenKeyError } from '../core/client.js';
+import { ConfigError } from '../core/config-error.js';
+import { normalizeGatewayOrigin } from '../core/origin.js';
+import { resolveOutputPath } from '../core/output-path.js';
+import { studioBindingDigest } from './cloud-service.js';
+import { projectOutputViews, cloudHttpError } from './cloud-contract.js';
+import { uuid } from './run-journal.js';
+import { StudioError } from './errors.js';
+import { saveOperation } from './output-save-contract.js';
+import { z } from 'zod';
+const receiptErrors = new WeakMap();
+function projectSave(operation, progress = null) { return { ...structuredClone(operation.receipt), progress }; }
+export function saveHttpError(error, bind = false) {
+    const projected = cloudHttpError(error);
+    const context = error instanceof Error ? receiptErrors.get(error) : undefined;
+    return { status: projected.status, body: { scope: context?.scope ?? null, save: context?.save ?? null, ...(bind ? { root: null } : {}), error: { ...projected.body.error, retryable: false, mayAlreadyBeSaved: context?.save.mayAlreadyBeSaved ?? null } } };
+}
+export function createOutputSaveService(options) {
+    let worker = options.worker;
+    const project = (op) => projectSave(op, worker?.progress?.(op.receipt.operationId, op.receipt.revision, op.receipt.attempt) ?? null);
+    const policy = Object.freeze({ configuredRoot: process.env.LUMENKEY_DOWNLOAD_ROOT });
+    const memory = new Map();
+    let epoch = 0;
+    let queue = Promise.resolve();
+    let active;
+    const invalidate = () => { epoch++; if (active)
+        worker?.suspend?.(active.scope.connectionId); active = undefined; };
+    function serial(fn) { const next = queue.then(fn); queue = next.catch(() => { }); return next; }
+    async function configuration() {
+        try {
+            const config = { ...await options.loadConfig() };
+            config.apiKey = config.apiKey?.trim();
+            if (!config.apiKey)
+                throw new StudioError('SAVE_CLOUD_CONFIG_REQUIRED', 409);
+            config.baseUrl = normalizeGatewayOrigin(config.baseUrl);
+            const client = new LumenKeyClient(config);
+            client.requireKey();
+            return studioBindingDigest(new URL(config.baseUrl).origin, config.apiKey);
+        }
+        catch (error) {
+            if (error instanceof ConfigError)
+                throw new LumenKeyError(error.code, 409);
+            throw new StudioError('SAVE_CLOUD_CONFIG_REQUIRED', 409);
+        }
+    }
+    function checkRoot() {
+        if (!options.outputDir)
+            return;
+        const raw = options.outputDir;
+        const absolute = path.resolve(raw);
+        if (!path.isAbsolute(raw) || /^[\\/]{2}/.test(raw) || absolute === path.parse(absolute).root || /^(?:[A-Za-z]:[\\/](?:Windows|Program Files(?: \(x86\))?|ProgramData)(?:[\\/]|$)|\/(?:etc|usr|sys|proc|dev|bin|sbin)(?:\/|$))/i.test(absolute))
+            throw new StudioError('SAVE_ROOT_NOT_ALLOWED', 403);
+        try {
+            resolveOutputPath(path.join(raw, 'LumenKey', 'assets'), 'absolute-only', undefined, policy);
+        }
+        catch {
+            throw new StudioError('SAVE_ROOT_NOT_ALLOWED', 403);
+        }
+    }
+    async function healthyAuthority() { await options.store?.saveAuthority.readIntegrity(); }
+    async function authorized() {
+        await healthyAuthority();
+        const bound = active;
+        const started = epoch;
+        let digest;
+        try {
+            digest = await configuration();
+        }
+        catch (error) {
+            invalidate();
+            throw error;
+        }
+        if (!bound)
+            throw new StudioError('SAVE_BINDING_REQUIRED', 403);
+        if (digest !== bound.digest || started !== epoch) {
+            invalidate();
+            throw new StudioError('SAVE_BINDING_REQUIRED', 403);
+        }
+        checkRoot();
+        const store = options.store;
+        if (!store)
+            throw new StudioError('SAVE_OUTPUT_ROOT_REQUIRED', 409);
+        const authority = await store.saveAuthority.read();
+        if (authority.rootId !== bound.scope.rootId || !authority.connections.some(c => c.connectionId === bound.scope.connectionId && c.bindingDigestRef === digest))
+            throw new StudioError('SAVE_BINDING_MISMATCH', 403);
+        if (started !== epoch)
+            throw new StudioError('SAVE_BINDING_REQUIRED', 403);
+        return { bound, authority, store, started };
+    }
+    function checkEpoch(access) { if (access.started !== epoch)
+        throw new StudioError('SAVE_BINDING_REQUIRED', 403); }
+    async function outputViews(access, runId) {
+        if (!uuid.safeParse(runId).success)
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        const data = await access.store.runs.read();
+        const run = data.runs.find(r => r.runId === runId);
+        if (!run)
+            throw new StudioError('STUDIO_RUN_NOT_FOUND', 404);
+        if (run.binding !== access.bound.digest)
+            throw new StudioError('SAVE_BINDING_MISMATCH', 403);
+        checkEpoch(access);
+        const operations = access.authority.operations.filter(o => o.connectionId === access.bound.scope.connectionId && o.receipt.runId === runId);
+        const seen = new Set();
+        const views = projectOutputViews(run, { rootReady: true, authorityHealthy: true }).map((view, index) => {
+            // This index only pairs two projections of the SAME snapshot. Identity is
+            // matched exclusively by its gateway UUID, never by a historical ordinal.
+            const sourceId = run.job?.outputs[index]?.assetId;
+            const found = uuid.safeParse(sourceId).success ? operations.find(o => o.receipt.gatewayAssetId.toLowerCase() === sourceId.toLowerCase() && o.receipt.jobId === view.jobId) : undefined;
+            if (found)
+                seen.add(found.receipt.operationId);
+            return { ...view, ...(found ? { acceptance: 'ACCEPTED', saveAllowed: false, saveBlockedCode: view.saveBlockedCode ?? 'SAVE_OPERATION_EXISTS', saveOperationId: found.receipt.operationId } : {}), save: found ? project(found) : null };
+        });
+        for (const found of operations)
+            if (!seen.has(found.receipt.operationId)) {
+                const reason = run.job?.identityReason ?? 'NO_VERIFIABLE_OUTPUTS';
+                const type = run.job?.identityEvidence?.find(o => o.assetId.toLowerCase() === found.receipt.gatewayAssetId.toLowerCase())?.type ?? null;
+                views.push({ localOutputId: null, runId, jobId: found.receipt.jobId, gatewayAssetId: null, outputIndex: null, displayOrdinal: views.length + 1,
+                    outputType: type, mediaType: null, identity: { status: 'UNVERIFIED', reason }, acceptance: 'ACCEPTED', saveAllowed: false,
+                    saveBlockedCode: reason === 'IDENTITY_CONFLICT' ? 'SAVE_OUTPUT_IDENTITY_CONFLICT' : 'SAVE_OUTPUT_IDENTITY_UNVERIFIED', saveOperationId: found.receipt.operationId, save: project(found) });
+            }
+        return views;
+    }
+    async function selected(access, runId, localOutputId) {
+        if (!uuid.safeParse(localOutputId).success)
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        const views = await outputViews(access, runId);
+        const found = views.find(v => v.localOutputId === localOutputId || v.save?.localOutputId === localOutputId);
+        if (!found)
+            throw new StudioError('SAVE_OUTPUT_IDENTITY_UNVERIFIED', 409);
+        return found;
+    }
+    function operation(access, id) {
+        if (!uuid.safeParse(id).success)
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        const found = access.authority.operations.find(o => o.receipt.operationId === id);
+        if (!found)
+            throw new StudioError('SAVE_OPERATION_NOT_FOUND', 404);
+        if (found.connectionId !== access.bound.scope.connectionId)
+            throw new StudioError('SAVE_BINDING_MISMATCH', 403);
+        return found;
+    }
+    return {
+        invalidate,
+        localScope: () => active ? structuredClone(active.scope) : null,
+        preflight: (bind = false) => serial(async () => { if (bind) {
+            await healthyAuthority();
+            await configuration();
+            checkRoot();
+        }
+        else {
+            await authorized();
+        } }),
+        bind: () => serial(async () => {
+            invalidate();
+            await healthyAuthority();
+            const started = epoch;
+            const digest = await configuration();
+            checkRoot();
+            let scope;
+            let root = null;
+            if (options.store) {
+                const snapshot = await options.store.saveAuthority.bind(digest);
+                scope = { rootId: snapshot.rootId, connectionId: snapshot.connections.find(c => c.bindingDigestRef === digest).connectionId };
+                root = { absolutePath: snapshot.canonicalAssetsPath };
+            }
+            else {
+                let id = memory.get(digest);
+                if (!id) {
+                    id = randomUUID();
+                    memory.set(digest, id);
+                }
+                scope = { rootId: null, connectionId: id };
+            }
+            if (root && !worker)
+                worker = options.makeWorker?.();
+            await worker?.recover?.();
+            if (started !== epoch)
+                throw new StudioError('SAVE_BINDING_REQUIRED', 403);
+            worker?.activate?.(scope.connectionId);
+            active = { digest, scope };
+            return { scope, root, code: root ? null : 'SAVE_OUTPUT_ROOT_REQUIRED' };
+        }),
+        outputs: (runId) => serial(async () => {
+            const a = await authorized();
+            return { scope: a.bound.scope, revision: a.authority.revision, items: await outputViews(a, runId) };
+        }),
+        output: (runId, localOutputId) => serial(async () => {
+            let a = await authorized();
+            let output = await selected(a, runId, localOutputId);
+            if (output.save?.asset) {
+                await a.store.metadata(output.save.asset.assetId);
+                a = await authorized();
+                output = await selected(a, runId, localOutputId);
+            }
+            return { scope: a.bound.scope, revision: a.authority.revision, output, acceptance: output.acceptance, save: output.save };
+        }),
+        accept: (runId, localOutputId, body) => serial(async () => {
+            const a = await authorized();
+            const view = await selected(a, runId, localOutputId);
+            const request = z.object({ requestId: uuid }).strict().safeParse(body);
+            if (!request.success)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            if (!view.save && !view.saveAllowed)
+                throw new StudioError(view.saveBlockedCode, view.saveBlockedCode === 'SAVE_MEDIA_UNSUPPORTED' ? 415 : 409);
+            checkEpoch(a);
+            const accepted = await a.store.saveAuthority.accept({ connectionId: a.bound.scope.connectionId, requestId: request.data.requestId, localOutputId, runId, jobId: view.jobId, gatewayAssetId: view.gatewayAssetId ?? view.save.gatewayAssetId });
+            const latest = await a.store.saveAuthority.read();
+            worker?.enqueue(accepted.receipt.operationId);
+            return { status: ['ACCEPTED', 'SAVING'].includes(accepted.receipt.state) ? 202 : 200, scope: a.bound.scope, revision: latest.revision, save: project(accepted) };
+        }),
+        read: (id) => serial(async () => {
+            let a = await authorized();
+            let found = operation(a, id);
+            if (found.receipt.asset) {
+                await a.store.metadata(found.assetId);
+                a = await authorized();
+                found = operation(a, id);
+            }
+            return { scope: a.bound.scope, revision: a.authority.revision, save: project(found) };
+        }),
+        retry: (id, body) => serial(async () => {
+            const a = await authorized();
+            const found = operation(a, id);
+            const parsed = z.object({ expectedRevision: z.number().int().positive().safe() }).strict().safeParse(body);
+            if (!parsed.success)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const reject = (code) => { const error = new StudioError(code, 409); receiptErrors.set(error, { scope: a.bound.scope, save: project(found) }); throw error; };
+            if (parsed.data.expectedRevision !== found.receipt.revision)
+                reject('SAVE_REVISION_CONFLICT');
+            if (!found.receipt.safeRetry || !['FAILED', 'RECOVERY_REQUIRED'].includes(found.receipt.state))
+                reject('SAVE_RETRY_NOT_ALLOWED');
+            checkEpoch(a);
+            let updated;
+            try {
+                updated = worker?.retry ? await worker.retry(id, a.bound.scope.connectionId, parsed.data.expectedRevision) : await a.store.saveAuthority.update(id, a.bound.scope.connectionId, parsed.data.expectedRevision, { state: 'SAVING', stage: 'RECONCILING', attempt: found.receipt.attempt + 1, safeRetry: false, error: null });
+            }
+            catch (error) {
+                if (error instanceof StudioError && error.code === 'SAVE_REVISION_CONFLICT' && 'operation' in error) {
+                    const latest = saveOperation.safeParse(error.operation);
+                    if (latest.success && latest.data.connectionId === a.bound.scope.connectionId && latest.data.receipt.operationId === id)
+                        receiptErrors.set(error, { scope: a.bound.scope, save: project(latest.data) });
+                }
+                throw error;
+            }
+            return { status: updated.receipt.state === 'SAVED' ? 200 : 202, scope: a.bound.scope, revision: (await a.store.saveAuthority.read()).revision, save: project(updated) };
+        }),
+    };
+}
+//# sourceMappingURL=output-save-service.js.map