@lumenkey/cli 0.3.0 → 0.4.0-rc.1

package/dist/studio/cloud-service.d.ts

@@ -0,0 +1,178 @@
+import type { LumenKeyConfig } from '../core/types.js';
+import type { StudioAssetStore } from './asset-store.js';
+export declare function studioBindingDigest(origin: string, key: string): string;
+export declare function createStudioCloudService(options: {
+    store?: StudioAssetStore;
+    loadConfig: () => LumenKeyConfig | Promise<LumenKeyConfig>;
+}): {
+    status: () => {
+        gateway?: string | undefined;
+        connected: boolean;
+    };
+    connect: () => Promise<{
+        connected: boolean;
+        gateway: string;
+    }>;
+    disconnect: () => Promise<{
+        connected: boolean;
+    }>;
+    models: () => Promise<import("../core/types.js").ModelItem[]>;
+    balance: () => Promise<{
+        availableCredits: number;
+        reservedCredits: number;
+        updatedAt: string;
+    }>;
+    list: () => Promise<{
+        createdAt: string;
+        updatedAt: string;
+        failure?: {
+            code: string;
+            message: string;
+            type: string;
+            httpStatus?: number | undefined;
+            submission?: "created" | "none" | "unknown" | undefined;
+            recovery?: "expired" | "rerun" | "resume-command" | "ledger" | undefined;
+            resumeDeadline?: string | undefined;
+        } | undefined;
+        lastErrorCode?: string | undefined;
+        job?: {
+            status: "accepted" | "policy_checking" | "queued" | "submitting" | "provider_running" | "output_checking" | "succeeded" | "rejected" | "failed" | "cancelled" | "expired";
+            jobId: string;
+            outputs: {
+                url: string;
+                type?: string | undefined;
+                assetId?: string | undefined;
+                outputIndex?: number | undefined;
+            }[];
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+            identityReason?: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT" | undefined;
+        } | undefined;
+        runId: string;
+        modelId: string;
+        state: "QUOTED" | "SUBMISSION_UNKNOWN" | "SUBMISSION_REJECTED" | "ACCEPTED" | "TERMINAL";
+        quote: {
+            credits: number;
+            quoteId: string;
+            modelId: string;
+            expiresAt: string;
+        };
+    }[]>;
+    quote: (value: unknown) => Promise<{
+        createdAt: string;
+        updatedAt: string;
+        failure?: {
+            code: string;
+            message: string;
+            type: string;
+            httpStatus?: number | undefined;
+            submission?: "created" | "none" | "unknown" | undefined;
+            recovery?: "expired" | "rerun" | "resume-command" | "ledger" | undefined;
+            resumeDeadline?: string | undefined;
+        } | undefined;
+        lastErrorCode?: string | undefined;
+        job?: {
+            status: "accepted" | "policy_checking" | "queued" | "submitting" | "provider_running" | "output_checking" | "succeeded" | "rejected" | "failed" | "cancelled" | "expired";
+            jobId: string;
+            outputs: {
+                url: string;
+                type?: string | undefined;
+                assetId?: string | undefined;
+                outputIndex?: number | undefined;
+            }[];
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+            identityReason?: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT" | undefined;
+        } | undefined;
+        runId: string;
+        modelId: string;
+        state: "QUOTED" | "SUBMISSION_UNKNOWN" | "SUBMISSION_REJECTED" | "ACCEPTED" | "TERMINAL";
+        quote: {
+            credits: number;
+            quoteId: string;
+            modelId: string;
+            expiresAt: string;
+        };
+    }>;
+    confirm: (runId: string, confirm: unknown) => Promise<{
+        createdAt: string;
+        updatedAt: string;
+        failure?: {
+            code: string;
+            message: string;
+            type: string;
+            httpStatus?: number | undefined;
+            submission?: "created" | "none" | "unknown" | undefined;
+            recovery?: "expired" | "rerun" | "resume-command" | "ledger" | undefined;
+            resumeDeadline?: string | undefined;
+        } | undefined;
+        lastErrorCode?: string | undefined;
+        job?: {
+            status: "accepted" | "policy_checking" | "queued" | "submitting" | "provider_running" | "output_checking" | "succeeded" | "rejected" | "failed" | "cancelled" | "expired";
+            jobId: string;
+            outputs: {
+                url: string;
+                type?: string | undefined;
+                assetId?: string | undefined;
+                outputIndex?: number | undefined;
+            }[];
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+            identityReason?: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT" | undefined;
+        } | undefined;
+        runId: string;
+        modelId: string;
+        state: "QUOTED" | "SUBMISSION_UNKNOWN" | "SUBMISSION_REJECTED" | "ACCEPTED" | "TERMINAL";
+        quote: {
+            credits: number;
+            quoteId: string;
+            modelId: string;
+            expiresAt: string;
+        };
+    }>;
+    refresh: (runId: string) => Promise<{
+        createdAt: string;
+        updatedAt: string;
+        failure?: {
+            code: string;
+            message: string;
+            type: string;
+            httpStatus?: number | undefined;
+            submission?: "created" | "none" | "unknown" | undefined;
+            recovery?: "expired" | "rerun" | "resume-command" | "ledger" | undefined;
+            resumeDeadline?: string | undefined;
+        } | undefined;
+        lastErrorCode?: string | undefined;
+        job?: {
+            status: "accepted" | "policy_checking" | "queued" | "submitting" | "provider_running" | "output_checking" | "succeeded" | "rejected" | "failed" | "cancelled" | "expired";
+            jobId: string;
+            outputs: {
+                url: string;
+                type?: string | undefined;
+                assetId?: string | undefined;
+                outputIndex?: number | undefined;
+            }[];
+            error?: {
+                code: string;
+                message: string;
+            } | undefined;
+            identityReason?: "LEGACY_AWAITING_FRESH_GET" | "JOB_UNAVAILABLE" | "NO_VERIFIABLE_OUTPUTS" | "IDENTITY_CONFLICT" | undefined;
+        } | undefined;
+        runId: string;
+        modelId: string;
+        state: "QUOTED" | "SUBMISSION_UNKNOWN" | "SUBMISSION_REJECTED" | "ACCEPTED" | "TERMINAL";
+        quote: {
+            credits: number;
+            quoteId: string;
+            modelId: string;
+            expiresAt: string;
+        };
+    }>;
+};
+//# sourceMappingURL=cloud-service.d.ts.map

package/dist/studio/cloud-service.js

@@ -0,0 +1,202 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { LumenKeyClient, LumenKeyError } from '../core/client.js';
+import { ConfigError } from '../core/config-error.js';
+import { buildGenerationInput } from '../core/generation-input.js';
+import { classifyCreateFailure } from '../core/generation.js';
+import { normalizeGatewayOrigin } from '../core/origin.js';
+import { StudioError } from './errors.js';
+import { assertNoCredential, cloudDiagnostic, projectJob, projectModels, publicRun, quoteRequest, safeCloudCode, safeCloudFailure, validateInput } from './cloud-contract.js';
+import { isoDate, quoteSchema, uuid } from './run-journal.js';
+export function studioBindingDigest(origin, key) { return createHash('sha256').update(JSON.stringify([origin, key.trim()])).digest('hex'); }
+const terminal = new Set(['succeeded', 'failed', 'rejected', 'cancelled', 'expired']);
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.keys(value).sort().map(k => `${JSON.stringify(k)}:${canonical(value[k])}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+export function createStudioCloudService(options) {
+    let connection;
+    let queue = Promise.resolve();
+    function serial(fn) {
+        const next = queue.then(async () => {
+            try {
+                const result = await fn();
+                if (connection)
+                    assertNoCredential(result, connection.secret);
+                return result;
+            }
+            catch (error) {
+                throw safeCloudFailure(error, connection?.secret);
+            }
+        });
+        queue = next.catch(() => { });
+        return next;
+    }
+    function connected() { if (!connection)
+        throw new StudioError('STUDIO_CLOUD_DISCONNECTED', 409); return connection; }
+    function journal() { if (!options.store)
+        throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409); return options.store.runs; }
+    function find(data, runId, c) {
+        if (!uuid.safeParse(runId).success)
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        const run = data.runs.find(r => r.runId === runId && r.binding === c.binding);
+        if (!run)
+            throw new StudioError('STUDIO_RUN_NOT_FOUND', 404);
+        return run;
+    }
+    async function persist(data, run) {
+        await journal().write({ ...data, revision: data.revision + 1, runs: data.runs.map(r => r.runId === run.runId ? run : r) });
+    }
+    async function models(c) { return projectModels(await c.client.listModels(), c.secret); }
+    async function balance(c) {
+        const b = await c.client.getBalance();
+        const projected = { availableCredits: b.availableCredits, reservedCredits: b.reservedCredits, updatedAt: b.updatedAt };
+        if (!isoDate.safeParse(b.updatedAt).success)
+            throw new StudioError('STUDIO_CLOUD_RESPONSE_INVALID', 502);
+        assertNoCredential(projected, c.secret);
+        return projected;
+    }
+    return {
+        status: () => ({ connected: !!connection, ...(connection ? { gateway: connection.origin } : {}) }),
+        connect: () => serial(async () => {
+            connection = undefined;
+            let config;
+            let client;
+            try {
+                config = { ...await options.loadConfig() };
+                config.apiKey = typeof config.apiKey === 'string' ? config.apiKey.trim() : undefined;
+                config.baseUrl = normalizeGatewayOrigin(config.baseUrl);
+                config.projectId = config.projectId?.trim().toLowerCase() || undefined;
+                client = new LumenKeyClient(config);
+                client.requireKey();
+                if (config.projectId && !uuid.safeParse(config.projectId).success)
+                    throw new Error();
+            }
+            catch (error) {
+                if (error instanceof ConfigError)
+                    throw new LumenKeyError(error.code, 409);
+                throw new StudioError('STUDIO_CLOUD_CONFIG_INVALID', 409);
+            }
+            const origin = new URL(config.baseUrl).origin;
+            // Project selection does not change who pays: unresolved submission gate is credential-scoped.
+            const candidate = { client, origin, projectId: config.projectId, secret: config.apiKey, binding: studioBindingDigest(origin, config.apiKey) };
+            try {
+                await balance(candidate);
+            }
+            catch (error) {
+                throw safeCloudFailure(error, candidate.secret);
+            }
+            connection = candidate;
+            return { connected: true, gateway: origin };
+        }),
+        disconnect: () => serial(async () => { connection = undefined; return { connected: false }; }),
+        models: () => serial(async () => models(connected())),
+        balance: () => serial(async () => balance(connected())),
+        list: () => serial(async () => { const c = connected(); return (await journal().read()).runs.filter(r => r.binding === c.binding).map(publicRun); }),
+        quote: (value) => serial(async () => {
+            const c = connected();
+            const parsed = quoteRequest.safeParse(value);
+            if (!parsed.success)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const req = parsed.data;
+            assertNoCredential(req, c.secret);
+            const data = await journal().read();
+            const existing = data.runs.find(r => r.runId === req.requestId);
+            if (existing) {
+                if (existing.binding !== c.binding || existing.modelId !== req.modelId || canonical(existing.requestedInput ?? existing.input) !== canonical(req.input))
+                    throw new StudioError('STUDIO_RUN_CONFLICT', 409);
+                return publicRun(existing);
+            }
+            if (data.runs.length >= 1000)
+                throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+            const model = (await models(c)).find(m => m.id === req.modelId);
+            if (!model)
+                throw new StudioError('STUDIO_MODEL_NOT_AVAILABLE', 400);
+            let input;
+            try {
+                input = (await buildGenerationInput(c.client, req.modelId, req.input, [], model)).input;
+            }
+            catch (error) {
+                if (error instanceof LumenKeyError)
+                    throw safeCloudFailure(new LumenKeyError(safeCloudCode(error, c.secret), error.status ?? 400), c.secret, { submission: 'none' });
+                throw error;
+            }
+            validateInput(model, input);
+            assertNoCredential(input, c.secret);
+            const result = quoteSchema.safeParse(await c.client.getQuote({ modelId: req.modelId, input }));
+            if (!result.success || Date.parse(result.data.expiresAt) <= Date.now())
+                throw new StudioError('STUDIO_CLOUD_RESPONSE_INVALID', 502);
+            assertNoCredential(result.data, c.secret);
+            const now = new Date().toISOString();
+            const run = { runId: req.requestId, binding: c.binding, modelId: req.modelId, input, requestedInput: req.input, projectId: c.projectId ?? randomUUID(), idempotencyKey: randomUUID(), quote: result.data, state: 'QUOTED', createdAt: now, updatedAt: now };
+            await journal().write({ ...data, revision: data.revision + 1, runs: [...data.runs, run] });
+            return publicRun(run);
+        }),
+        confirm: (runId, confirm) => serial(async () => {
+            const c = connected();
+            if (confirm !== true)
+                throw new StudioError('STUDIO_CONFIRM_REQUIRED', 409);
+            let data = await journal().read();
+            let run = find(data, runId, c);
+            if (run.job)
+                return publicRun(run);
+            if (data.runs.some(r => r.binding === c.binding && ['SUBMITTING', 'SUBMISSION_UNKNOWN'].includes(r.state)))
+                throw new StudioError('STUDIO_SUBMISSION_UNRESOLVED', 409);
+            if (run.state !== 'QUOTED')
+                throw new StudioError('STUDIO_RUN_CONFLICT', 409);
+            if (Date.parse(run.quote.expiresAt) <= Date.now())
+                throw new StudioError('STUDIO_QUOTE_EXPIRED', 409);
+            run = { ...run, state: 'SUBMITTING', updatedAt: new Date().toISOString() };
+            await persist(data, run);
+            data = await journal().read();
+            if (Date.parse(run.quote.expiresAt) <= Date.now()) {
+                // No request was made: restore the expired quote rather than inventing an unknown charge.
+                await persist(data, { ...run, state: 'QUOTED', updatedAt: new Date().toISOString() });
+                throw new StudioError('STUDIO_QUOTE_EXPIRED', 409);
+            }
+            let postAnswered = false;
+            try {
+                const created = await c.client.createJob({ quoteId: run.quote.quoteId, projectId: run.projectId, input: run.input }, run.idempotencyKey);
+                postAnswered = true;
+                const job = projectJob(created, c.secret);
+                run = { ...run, state: terminal.has(job.status) ? 'TERMINAL' : 'ACCEPTED', job, updatedAt: new Date().toISOString() };
+                await persist(data, run);
+                return publicRun(run);
+            }
+            catch (error) {
+                // Only a failed first POST can prove no job was created. Projection or
+                // persistence after a response must never be reclassified as rejection.
+                if (!postAnswered && classifyCreateFailure(error, false) === 'none') {
+                    await persist(data, { ...run, state: 'SUBMISSION_REJECTED', lastErrorCode: safeCloudCode(error, c.secret), lastFailure: cloudDiagnostic(error, c.secret, { submission: 'none' }), updatedAt: new Date().toISOString() });
+                    throw safeCloudFailure(error, c.secret, { submission: 'none' });
+                }
+                // A failed response/persist cannot prove that the gateway did not accept.
+                const unknown = { ...run, state: 'SUBMISSION_UNKNOWN', lastErrorCode: safeCloudCode(error, c.secret), lastFailure: cloudDiagnostic(error, c.secret, { submission: run.job ? 'created' : 'unknown', recovery: run.job ? undefined : 'ledger' }), updatedAt: new Date().toISOString() };
+                await persist(data, unknown);
+                return publicRun(unknown);
+            }
+        }),
+        refresh: (runId) => serial(async () => {
+            const c = connected();
+            const data = await journal().read();
+            const run = find(data, runId, c);
+            if (!run.job)
+                throw new StudioError('STUDIO_SUBMISSION_UNRESOLVED', 409);
+            let job;
+            try {
+                job = projectJob(await c.client.getJob(run.job.jobId), c.secret, run.job, true);
+            }
+            catch (error) {
+                await persist(data, { ...run, job: { ...run.job, identityReason: run.job.identityReason === 'IDENTITY_CONFLICT' ? 'IDENTITY_CONFLICT' : 'JOB_UNAVAILABLE' }, updatedAt: new Date().toISOString() });
+                throw error;
+            }
+            const { lastFailure: _failure, lastErrorCode: _code, ...before } = run;
+            const next = { ...before, job, state: terminal.has(job.status) ? 'TERMINAL' : 'ACCEPTED', updatedAt: new Date().toISOString() };
+            await persist(data, next);
+            return publicRun(next);
+        }),
+    };
+}
+//# sourceMappingURL=cloud-service.js.map

package/dist/studio/director-captures.d.ts

@@ -0,0 +1,59 @@
+import { type CaptureBinding, type CaptureDelta } from './director-relations.js';
+import { StudioError } from './errors.js';
+import type { StudioCanvas, StudioCanvasAuthority } from './canvas-store.js';
+import type { StudioAsset } from './types.js';
+export interface CaptureView {
+    captureId: string;
+    assetId: string;
+    canvasId: string;
+    nodeId: string;
+    sceneId: string;
+    sceneRevision: number;
+    cameraId: string;
+    expectedCanvasRevision: number;
+    createdAt: string;
+    width: number;
+    height: number;
+    state: 'BOUND' | 'BINDING_PENDING' | 'BINDING_CONFLICT' | 'ASSET_UNAVAILABLE';
+    binding: CaptureBinding;
+    fileState: 'NOT_CHECKED' | 'READY' | 'MISSING' | 'CORRUPT';
+    retryable: boolean;
+}
+export interface CaptureReceipt {
+    status: 200 | 201 | 202;
+    capture: CaptureView;
+    canvas?: StudioCanvas;
+    relationDelta?: CaptureDelta;
+    replayed: boolean;
+}
+export declare class StudioCaptureError extends StudioError {
+    readonly capture: CaptureView;
+    constructor(code: 'STUDIO_CAPTURE_BINDING_CONFLICT' | 'STUDIO_CAPTURE_ASSET_UNAVAILABLE', capture: CaptureView);
+}
+export interface DirectorCaptureStore {
+    create(canvasId: string, input: unknown): Promise<CaptureReceipt>;
+    list(canvasId: string, input: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        items: CaptureView[];
+        nextCursor: string | null;
+    }>;
+    read(canvasId: string, captureId: string): Promise<{
+        capture: CaptureView;
+    }>;
+    retry(canvasId: string, captureId: string): Promise<CaptureReceipt>;
+}
+export interface CapturePorts {
+    maxBytes: number;
+    canvas: StudioCanvasAuthority;
+    assets(): Promise<StudioAsset[]>;
+    save(asset: StudioAsset, bytes: Uint8Array): Promise<StudioAsset>;
+    verify(asset: StudioAsset): Promise<'READY' | 'MISSING' | 'CORRUPT'>;
+    faults?: {
+        beforeCaptureCanvas?(): void | Promise<void>;
+        afterCaptureCanvas?(): void | Promise<void>;
+    };
+}
+export declare function createDirectorCaptureStore(ports: CapturePorts, serial: <T>(work: () => Promise<T>) => Promise<T>): DirectorCaptureStore;
+//# sourceMappingURL=director-captures.d.ts.map

package/dist/studio/director-captures.js

@@ -0,0 +1,141 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { directorUuid, parseDirectorScene, cameraDimensions, isDirectorJson } from './director-contract.js';
+import { DIRECTOR_MAX_PNG_BYTES, validateDirectorPng } from './director-png.js';
+import { captureBinding, canBindOriginal, withCaptureRelation } from './director-relations.js';
+import { StudioError } from './errors.js';
+export class StudioCaptureError extends StudioError {
+    capture;
+    constructor(code, capture) {
+        super(code, 409);
+        this.capture = capture;
+    }
+}
+const revision = z.number().int().nonnegative().safe();
+const inputSchema = z.object({ revision, nodeId: z.string().min(1).max(160).regex(/^[a-zA-Z0-9_-]+$/), sceneId: directorUuid, sceneRevision: revision, cameraId: directorUuid, captureId: directorUuid,
+    pngBase64: z.string().min(4).max(Math.ceil(DIRECTOR_MAX_PNG_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+}).strict();
+function validId(id) { if (!directorUuid.safeParse(id).success)
+    throw new StudioError('STUDIO_INPUT_INVALID'); }
+const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export function createDirectorCaptureStore(ports, serial) {
+    async function readCanvas(id) { try {
+        return await ports.canvas.read(id);
+    }
+    catch (e) {
+        if (e instanceof StudioError && e.code === 'STUDIO_CANVAS_NOT_FOUND')
+            return undefined;
+        throw e;
+    } }
+    function project(asset, canvas, fileState = 'NOT_CHECKED') {
+        const p = asset.directorCapture, { binding, history } = captureBinding(canvas, asset);
+        const bound = history && binding.reference && binding.assetNode && binding.connection;
+        const pending = !bound && canBindOriginal(canvas, asset);
+        const unavailable = fileState === 'MISSING' || fileState === 'CORRUPT';
+        return { captureId: p.captureId, assetId: asset.assetId, canvasId: p.canvasId, nodeId: p.nodeId, sceneId: p.sceneId, sceneRevision: p.sceneRevision, cameraId: p.cameraId, expectedCanvasRevision: p.expectedCanvasRevision,
+            createdAt: asset.savedAt, width: p.width, height: p.height, binding, fileState, state: unavailable ? 'ASSET_UNAVAILABLE' : bound ? 'BOUND' : pending ? 'BINDING_PENDING' : 'BINDING_CONFLICT', retryable: pending && !unavailable };
+    }
+    async function find(canvasId, captureId) { validId(canvasId); validId(captureId); const asset = (await ports.assets()).find(a => a.directorCapture?.captureId === captureId && a.directorCapture.canvasId === canvasId); if (!asset)
+        throw new StudioError('STUDIO_CAPTURE_NOT_FOUND', 404); return asset; }
+    async function bind(asset, replayed) {
+        const p = asset.directorCapture, canvas = await readCanvas(p.canvasId), view = project(asset, canvas, await ports.verify(asset));
+        if (view.state === 'ASSET_UNAVAILABLE')
+            throw new StudioCaptureError('STUDIO_CAPTURE_ASSET_UNAVAILABLE', view);
+        if (view.state === 'BOUND')
+            return { status: 200, capture: view, canvas, replayed: true };
+        if (!view.retryable || !canvas)
+            throw new StudioCaptureError('STUDIO_CAPTURE_BINDING_CONFLICT', view);
+        let saved, relationDelta;
+        try {
+            const relation = withCaptureRelation(canvas, asset);
+            relationDelta = relation.delta;
+            await ports.faults?.beforeCaptureCanvas?.();
+            saved = await ports.canvas.save(canvas.id, { revision: canvas.revision, name: canvas.name, snapshot: relation.snapshot });
+        }
+        catch (error) {
+            // Determine disk authority after a failed commit. A malformed/unreadable
+            // authority cannot be advertised as a known partial success.
+            await ports.assets().catch(() => { throw new StudioError('STUDIO_CAPTURE_OUTCOME_UNKNOWN', 503); });
+            const current = await readCanvas(p.canvasId).catch(() => { throw new StudioError('STUDIO_CAPTURE_OUTCOME_UNKNOWN', 503); });
+            const check = project(asset, current, await ports.verify(asset));
+            if (check.state === 'BOUND')
+                return { status: 200, capture: check, canvas: current, replayed: true };
+            if (check.state === 'BINDING_PENDING')
+                return { status: 202, capture: check, replayed };
+            if (check.state === 'ASSET_UNAVAILABLE')
+                throw new StudioCaptureError('STUDIO_CAPTURE_ASSET_UNAVAILABLE', check);
+            throw new StudioCaptureError('STUDIO_CAPTURE_BINDING_CONFLICT', check);
+        }
+        try {
+            await ports.faults?.afterCaptureCanvas?.();
+        }
+        catch {
+            throw new StudioError('STUDIO_CAPTURE_OUTCOME_UNKNOWN', 503);
+        }
+        return { status: replayed ? 200 : 201, capture: project(asset, saved, 'READY'), canvas: saved, relationDelta, replayed };
+    }
+    return {
+        create: (canvasId, value) => serial(async () => {
+            validId(canvasId);
+            if (!isDirectorJson(value))
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const parsed = inputSchema.safeParse(value);
+            if (!parsed.success)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const input = parsed.data;
+            const bytes = Buffer.from(input.pngBase64, 'base64');
+            if (bytes.length > DIRECTOR_MAX_PNG_BYTES || bytes.toString('base64') !== input.pngBase64)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const requestHash = sha(JSON.stringify([canvasId, input.revision, input.nodeId, input.sceneId, input.sceneRevision, input.cameraId, input.captureId, sha(bytes)]));
+            const existing = (await ports.assets()).find(a => a.directorCapture?.captureId === input.captureId);
+            if (existing) {
+                if (existing.directorCapture.requestHash !== requestHash)
+                    throw new StudioError('STUDIO_CAPTURE_ID_CONFLICT', 409);
+                return bind(existing, true);
+            }
+            if (bytes.length > ports.maxBytes)
+                throw new StudioError('STUDIO_MEDIA_TOO_LARGE', 413);
+            const canvas = await ports.canvas.read(canvasId), n = canvas.snapshot.nodes.find(n => n.id === input.nodeId && ['image', 'video'].includes(n.type));
+            if (!n)
+                throw new StudioError('STUDIO_CANVAS_NOT_FOUND', 404);
+            const scene = n.metadata.studioDirector === undefined ? undefined : parseDirectorScene(n.metadata.studioDirector), camera = scene?.cameras.find(c => c.id === input.cameraId);
+            if (canvas.revision !== input.revision || scene?.sceneId !== input.sceneId || scene.sceneRevision !== input.sceneRevision || !camera)
+                throw new StudioError('STUDIO_CAPTURE_BINDING_CONFLICT', 409);
+            const dimensions = cameraDimensions(camera.aspect);
+            validateDirectorPng(bytes, dimensions);
+            const provenance = { captureId: input.captureId, requestHash, canvasId, expectedCanvasRevision: input.revision, nodeId: input.nodeId, sceneId: input.sceneId, sceneRevision: input.sceneRevision, cameraId: input.cameraId, ...dimensions };
+            const assetId = randomUUID(), asset = { assetId, displayName: '镜头截图.png', mediaType: 'image/png', relativePath: `assets/${assetId}.png`, byteLength: bytes.length, sha256: sha(bytes), savedAt: new Date().toISOString(), directorCapture: provenance };
+            const { snapshot } = withCaptureRelation(canvas, asset);
+            await ports.canvas.previewSave(canvasId, { revision: canvas.revision, name: canvas.name, snapshot }, [asset]);
+            try {
+                await ports.save(asset, bytes);
+            }
+            catch {
+                throw new StudioError('STUDIO_CAPTURE_OUTCOME_UNKNOWN', 503);
+            }
+            return bind(asset, false);
+        }),
+        list: (canvasId, input) => serial(async () => {
+            validId(canvasId);
+            const parsed = z.object({ limit: z.number().int().min(1).max(100).optional(), cursor: z.string().min(1).max(256).regex(/^[A-Za-z0-9_-]+$/).optional() }).strict().safeParse(input);
+            if (!parsed.success)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const rows = (await ports.assets()).filter(a => a.directorCapture?.canvasId === canvasId).sort((a, b) => a.savedAt.localeCompare(b.savedAt) || a.directorCapture.captureId.localeCompare(b.directorCapture.captureId)), canvas = await readCanvas(canvasId);
+            if (!canvas && !rows.length)
+                throw new StudioError('STUDIO_CANVAS_NOT_FOUND', 404);
+            let start = 0;
+            const cursor = parsed.data.cursor;
+            if (cursor) {
+                const at = rows.findIndex(a => Buffer.from(JSON.stringify([a.savedAt, a.directorCapture.captureId])).toString('base64url') === cursor);
+                if (at < 0)
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                start = at + 1;
+            }
+            const selected = rows.slice(start, start + (parsed.data.limit ?? 20)), last = selected.at(-1);
+            return { items: selected.map(a => project(a, canvas)), nextCursor: start + selected.length < rows.length && last ? Buffer.from(JSON.stringify([last.savedAt, last.directorCapture.captureId])).toString('base64url') : null };
+        }),
+        read: (canvasId, captureId) => serial(async () => { const asset = await find(canvasId, captureId); return { capture: project(asset, await readCanvas(canvasId), await ports.verify(asset)) }; }),
+        retry: (canvasId, captureId) => serial(async () => bind(await find(canvasId, captureId), true)),
+    };
+}
+//# sourceMappingURL=director-captures.js.map