@playcraft/cli 0.1.66 → 0.1.67

package/dist/workspace-runtime/server/accept-operation.js

@@ -1,7 +1,47 @@
-import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, } from '@playcraft/common/cloud-workspace/runtime';
-import { canExecuteKind, executeOperation } from './dispatch.js';
+import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { canExecuteKind, executeOperation, reconcileLevelEditorTransaction } from './dispatch.js';
 import { buildOperationRecord } from './operation-record.js';
 import { preflightSkillExecution } from '../workspaces/skill-execution-context.js';
+import { reconcileLevelEditorRetryRequest } from '../workspaces/level-editor-requests.js';
+async function reconcileRetryRegistration(state, scopeKey, operation) {
+    const proof = await reconcileLevelEditorRetryRequest(state, operation);
+    if (!proof)
+        return undefined;
+    let current = operation;
+    if (current.status === 'queued')
+        current = transitionOperation(current, 'dispatched');
+    if (current.status === 'dispatched')
+        current = transitionOperation(current, 'accepted');
+    return state.journal.putOperation(scopeKey, transitionOperation(current, 'completed', { result: proof, error: undefined }));
+}
+/** Observation completes proven saves and control registrations without resubmitting their execution. */
+export async function observeLevelEditorTransaction(state, operation) {
+    if (operation.kind === 'level-editor.request' &&
+        ['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status)) {
+        const scopeKey = operationScopeKey(operation);
+        return state.journal
+            .exclusive(scopeKey, async () => {
+            const current = state.journal.getOperation(scopeKey);
+            if (!current || current.operationId !== operation.operationId)
+                return current ?? operation;
+            return (await reconcileRetryRegistration(state, scopeKey, current)) ?? current;
+        })
+            .catch(() => operation);
+    }
+    if (operation.kind !== 'level-editor.transaction' || !['dispatched', 'accepted', 'uncertain'].includes(operation.status))
+        return operation;
+    const scopeKey = operationScopeKey(operation);
+    return state.journal
+        .exclusive(scopeKey, async () => {
+        const current = state.journal.getOperation(scopeKey);
+        if (!current ||
+            current.operationId !== operation.operationId ||
+            !['dispatched', 'accepted', 'uncertain'].includes(current.status))
+            return current ?? operation;
+        return (await reconcileLevelEditorTransaction(state, scopeKey, current)) ?? current;
+    })
+        .catch(() => operation);
+}
 /**
  * Shared operation acceptance: lease fence, idempotency, capability, record creation and
  * execution. HTTP supplies its transport/session checks through `validate`; in-sandbox Agent
@@ -38,26 +78,51 @@ export async function acceptOperationCore(state, parsed, options) {
             }
             if (!decision.operation.gatewayOperationId) {
                 decision.operation = await state.journal.putOperation(scopeKey, {
-                    ...decision.operation, gatewayOperationId: parsed.gatewayOperationId,
+                    ...decision.operation,
+                    gatewayOperationId: parsed.gatewayOperationId,
                 });
             }
         }
-        const retryWithRecovery = decision.action === 'reuse' && parsed.kind === 'session.turn'
-            && Boolean(parsed.sessionRecovery) && decision.operation.status === 'failed'
-            && isLostThreadError(decision.operation.error);
+        const retryWithRecovery = decision.action === 'reuse' &&
+            parsed.kind === 'session.turn' &&
+            Boolean(parsed.sessionRecovery) &&
+            decision.operation.status === 'failed' &&
+            isLostThreadError(decision.operation.error);
         if (decision.action === 'reuse' && !retryWithRecovery) {
+            if (decision.operation.kind === 'level-editor.request') {
+                const reconciled = await reconcileRetryRegistration(state, scopeKey, decision.operation).catch(() => undefined);
+                if (reconciled)
+                    return { rejected: false, operation: reconciled, executed: reconciled, reused: true };
+            }
+            if (decision.operation.kind === 'level-editor.transaction' && ['dispatched', 'accepted', 'uncertain'].includes(decision.operation.status)) {
+                const validation = await options.validate?.(scopeKey);
+                if (validation)
+                    return { rejected: true, refusal: validation };
+                const reconciled = await reconcileLevelEditorTransaction(state, scopeKey, decision.operation, options.executionPayload).catch(() => undefined);
+                if (reconciled)
+                    return { rejected: false, operation: reconciled, executed: reconciled, reused: true };
+            }
             if (decision.operation.status === 'uncertain') {
                 return rejected(409, runtimeError('uncertain_operation', decision.operation.error ?? 'native_receipt_lost', {
                     operationId: decision.operation.operationId,
                 }));
             }
-            if (decision.operation.status === 'queued' && takesWorkspaceDirectory(decision.operation.kind) &&
-                !isTurnControl(decision.operation.kind) && !state.journal.deferredDirectoryOperations().some(item => item.operationId === decision.operation.operationId)) {
+            if (decision.operation.status === 'queued' &&
+                takesWorkspaceDirectory(decision.operation.kind) &&
+                !isTurnControl(decision.operation.kind) &&
+                !state.journal
+                    .deferredDirectoryOperations()
+                    .some((item) => item.operationId === decision.operation.operationId)) {
                 const queued = await state.journal.putPendingOperation(scopeKey, decision.operation, options.executionPayload, parsed.sessionRecovery);
                 const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
                 return { rejected: false, operation: executed, executed, reused: true };
             }
-            return { rejected: false, operation: decision.operation, executed: decision.operation, reused: true };
+            return {
+                rejected: false,
+                operation: decision.operation,
+                executed: decision.operation,
+                reused: true,
+            };
         }
         const validation = await options.validate?.(scopeKey);
         if (validation)
@@ -68,17 +133,24 @@ export async function acceptOperationCore(state, parsed, options) {
             policy = await preflightSkillExecution(state, parsed);
         }
         catch (error) {
-            return rejected(409, { error: error instanceof Error && /^(?:context_|invalid_composer_context|untrusted_runtime_field)/.test(error.message)
-                    ? error.message : 'context_skill_unavailable' });
+            return rejected(409, {
+                error: error instanceof Error && /^(?:context_|invalid_composer_context|untrusted_runtime_field)/.test(error.message)
+                    ? error.message
+                    : 'context_skill_unavailable',
+            });
         }
         const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable, policy);
         if (!executable) {
             const saved = await state.journal.putOperation(scopeKey, operation);
-            return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed() ? 'runtime_destroyed' : state.nativeError ?? 'adapter_not_started', { operationId: saved.operationId }));
+            return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed()
+                ? 'runtime_destroyed'
+                : (state.nativeError ?? 'adapter_not_started'), { operationId: saved.operationId }));
         }
         state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, options.leaseFence);
         await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
-        const queued = takesWorkspaceDirectory(operation.kind) && !isTurnControl(operation.kind) && operation.kind !== 'runtime.destroy'
+        const queued = takesWorkspaceDirectory(operation.kind) &&
+            !isTurnControl(operation.kind) &&
+            operation.kind !== 'runtime.destroy'
             ? await state.journal.putPendingOperation(scopeKey, operation, options.executionPayload, parsed.sessionRecovery)
             : await state.journal.putOperation(scopeKey, operation);
         const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);

package/dist/workspace-runtime/server/audio-assets.js

@@ -0,0 +1,211 @@
+import { z } from 'zod';
+import { workspaceAudioTargetSchema, workspaceRelativePathSchema, workspaceAudioProtectionSchema, isSoundDocumentPath } from '@playcraft/common/cloud-workspace/runtime';
+import { WorkspaceAudioAssets } from '../workspaces/audio-assets/service.js';
+import { audioRendererScript, workspaceAudioRenderer } from '../workspaces/audio-assets/renderer.js';
+import { audioError } from '../workspaces/audio-assets/storage.js';
+import { workspaceRoot, revisionScope } from '../workspaces/registry.js';
+import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
+import { wakeSourceEventUploader } from './source-uploader.js';
+import { withDirectoryWrite } from './directory-access.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
+const hash = z.string().regex(/^[a-f0-9]{64}$/);
+const actionSchema = z.object({
+    action: z.enum(['create-candidate', 'save', 'render', 'adopt', 'rollback', 'bind']),
+    requestId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/), target: z.unknown().refine(value => value === undefined || workspaceAudioTargetSchema.safeParse(value).success).optional(),
+    taskId: z.string().uuid().optional(), candidateId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/).optional(),
+    document: z.unknown().optional(), expectedRevision: z.number().int().positive().optional(), expectedContentHash: hash.nullable().optional(),
+    path: z.string().refine(value => isSoundDocumentPath(value) && workspaceRelativePathSchema.safeParse(value).success).optional(),
+    expectedDestinationRevision: z.number().int().nonnegative().optional(), expectedDestinationContentHash: hash.nullable().optional(),
+    versionRevision: z.number().int().positive().optional(), eventName: z.string().max(64).optional(),
+    protection: z.unknown().refine(value => value === undefined || workspaceAudioProtectionSchema.safeParse(value).success).optional(),
+}).strict();
+const services = new WeakMap();
+const probes = new WeakMap();
+function send(response, status, value) {
+    if (response.destroyed || response.headersSent)
+        return;
+    response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    response.end(JSON.stringify(value));
+}
+async function body(request) {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+        size += Buffer.byteLength(chunk);
+        if (size > 96 * 1024)
+            throw audioError('audio_budget_exceeded', 413);
+        chunks.push(Buffer.from(chunk));
+    }
+    try {
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+    }
+    catch {
+        throw audioError('invalid_audio_request', 400);
+    }
+}
+function targetFrom(url) {
+    const value = url.searchParams.has('path') ? { kind: 'workspace-file', path: url.searchParams.get('path') } :
+        { kind: 'generation-candidate', taskId: url.searchParams.get('taskId'), candidateId: url.searchParams.get('candidateId') };
+    const parsed = workspaceAudioTargetSchema.safeParse(value);
+    if (!parsed.success)
+        throw audioError('invalid_audio_target', 400);
+    return parsed.data;
+}
+export async function workspaceAudioAssetService(state, workspaceId, directoryName) {
+    const root = await workspaceRoot(state, workspaceId, directoryName), scope = `${workspaceId ?? 'single'}:${directoryName}`;
+    let entries = services.get(state);
+    if (!entries) {
+        entries = new Map();
+        services.set(state, entries);
+    }
+    let value = entries.get(scope);
+    if (!value || value.projectRoot !== root) {
+        value = new WorkspaceAudioAssets(root, state.config.stateDir, scope, {
+            render: workspaceAudioRenderer(state, root, scope),
+            onWrite: async (path, version, paths, requestId) => {
+                await state.journal.putFileRevision(path, { revision: version.revision, contentHash: version.contentHash }, revisionScope(state, workspaceId, directoryName));
+                for (const type of ['file.written', 'files.changed'])
+                    await state.journal.allocateSourceEvent({
+                        runtimeId: state.config.runtimeId, generation: state.config.generation, runtimeEpoch: state.runtimeEpoch,
+                        workspaceId, operationId: requestId, type, occurredAt: new Date().toISOString(),
+                        payload: { ...(workspaceId ? { workspaceId } : {}), directoryName, path, paths, revision: version.revision, contentHash: version.contentHash },
+                    });
+                wakeSourceEventUploader(state);
+                if (workspaceId && paths.some(item => item.startsWith('dist/')))
+                    await refreshWorkspaceArtifacts(state, workspaceId, { paths, source: { kind: 'generated', operationId: requestId, tool: 'audio' } }, directoryName);
+            },
+        });
+        entries.set(scope, value);
+    }
+    return value;
+}
+async function rendererProbe(state, root, scope, kind = 'synth-sfx') {
+    let entries = probes.get(state);
+    if (!entries) {
+        entries = new Map();
+        probes.set(state, entries);
+    }
+    const key = `${scope}:${kind}`;
+    let probe = entries.get(key);
+    if (!probe) {
+        probe = (async () => {
+            try {
+                const bundle = await audioRendererScript(kind);
+                const source = kind === 'score' ? { format: 'playcraft.score', formatVersion: 1, name: 'score-renderer-probe',
+                    engine: { id: 'playcraft-webaudio-score', version: '1.0.0' }, dependencies: [],
+                    content: { kind: 'score', tempoBpm: 120, timeSignature: { numerator: 4, denominator: 4 }, lengthBeats: 1,
+                        masterGain: .1, loop: { enabled: false, startBeat: 0, endBeat: 1 }, tracks: [{ id: 'probe', name: 'Probe', instrument: 'sine',
+                                gain: .1, muted: false, solo: false, notes: [{ id: 'probe_note', startBeat: 0, durationBeats: .5, pitch: 69, velocity: .1 }], automation: [] }] } }
+                    : { format: 'playcraft.audio', formatVersion: 1, name: 'renderer-probe',
+                        engine: { id: 'playcraft-webaudio-sfx', version: '1.0.0' }, dependencies: [],
+                        content: { kind: 'synth-sfx', durationSeconds: .05, seed: 0, masterGain: .1,
+                            voices: [{ id: 'probe', startSeconds: 0, durationSeconds: .05, gain: .1, source: { kind: 'oscillator', waveform: 'sine', frequencyHz: 440 },
+                                    envelope: { attackSeconds: .002, decaySeconds: .01, sustainLevel: .5, releaseSeconds: .01 }, filter: null }], automation: [] } };
+                await workspaceAudioRenderer(state, root, scope)(source);
+                return { ready: true, rendererBuildHash: bundle.rendererBuildHash };
+            }
+            catch {
+                return { ready: false, reason: 'engine_unavailable' };
+            }
+        })();
+        entries.set(key, probe);
+        const timer = setTimeout(() => entries.delete(key), 30_000);
+        timer.unref();
+    }
+    return probe;
+}
+/** Audio protocol negotiation is independent of legacy binary audio export. */
+export async function handleAudioAssetRequest(state, request, response, url) {
+    if (!['/runtime/audio/capabilities', '/runtime/audio/assets', '/runtime/audio/content', '/runtime/audio/actions'].includes(url.pathname))
+        return false;
+    try {
+        if (request.headers['x-playcraft-audio-protocol'] !== '1')
+            throw audioError('audio_protocol_required', 426);
+        const workspaceId = url.searchParams.get('workspaceId') ?? undefined, directoryName = url.searchParams.get('directoryName') ?? 'basic';
+        const root = await workspaceRoot(state, workspaceId, directoryName), enabled = process.env.CLOUD_WORKSPACE_AUDIO_ASSETS_ENABLED === 'true';
+        if (request.method === 'GET' && url.pathname === '/runtime/audio/capabilities') {
+            const renderer = enabled ? await rendererProbe(state, root, `${workspaceId ?? 'single'}:${directoryName}`) : { ready: false, reason: 'feature_disabled' };
+            const scoreRenderer = enabled && request.headers['x-playcraft-audio-score-protocol'] === '1'
+                ? await rendererProbe(state, root, `${workspaceId ?? 'single'}:${directoryName}`, 'score') : { ready: false, reason: enabled ? 'audio_score_protocol_required' : 'feature_disabled' };
+            send(response, 200, { version: 1, audioAssetVersion: 1, audioScoreVersion: 1, audioScoreContextVersion: 1,
+                enabled, writable: enabled, documentVersions: [1], contentKinds: request.headers['x-playcraft-audio-score-protocol'] === '1' ? ['synth-sfx', 'score'] : ['synth-sfx'],
+                renderer: { ...renderer, engineId: 'playcraft-webaudio-sfx', engineVersion: '1.0.0' },
+                scoreRenderer: { ...scoreRenderer, engineId: 'playcraft-webaudio-score', engineVersion: '1.0.0' },
+                operations: { read: true, content: true, generate: enabled && renderer.ready, save: enabled, render: enabled && renderer.ready,
+                    adopt: enabled && renderer.ready, rollback: enabled, bind: enabled && renderer.ready } });
+            return true;
+        }
+        const assets = await workspaceAudioAssetService(state, workspaceId, directoryName);
+        const requireScore = (score) => { if (score && request.headers['x-playcraft-audio-score-protocol'] !== '1')
+            throw audioError('audio_score_protocol_required', 426); };
+        if (request.method === 'GET' && url.pathname === '/runtime/audio/assets') {
+            const result = await assets.read(targetFrom(url));
+            requireScore(result.document.format === 'playcraft.score');
+            send(response, 200, result);
+            return true;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/audio/content') {
+            const revision = url.searchParams.has('revision') ? Number(url.searchParams.get('revision')) : undefined;
+            if (revision !== undefined && (!Number.isSafeInteger(revision) || revision < 1))
+                throw audioError('invalid_audio_request', 400);
+            const target = targetFrom(url), current = await assets.read(target);
+            requireScore(current.document.format === 'playcraft.score');
+            const result = await assets.content(target, revision, url.searchParams.get('representation') === 'source' ? 'source' : 'audition');
+            response.writeHead(200, { 'content-type': result.mimeType, 'content-length': result.bytes.length, etag: `"${result.contentHash}"`, 'cache-control': 'private, no-store' });
+            response.end(result.bytes);
+            return true;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/audio/actions') {
+            if (!enabled)
+                throw audioError('audio_feature_disabled', 403);
+            if (state.journal.destroyed())
+                throw audioError('runtime_destroyed');
+            const sessionId = url.searchParams.get('sessionId');
+            if (sessionId) {
+                const session = state.journal.getSession(sessionId);
+                if (!session || session.workspaceId !== workspaceId || (session.directoryName ?? 'basic') !== directoryName)
+                    throw audioError('audio_scope_mismatch', 403);
+                if (session.permissionMode === 'read-only')
+                    throw audioError('plan_mode_write_forbidden', 403);
+            }
+            const parsed = actionSchema.safeParse(await body(request));
+            if (!parsed.success)
+                throw audioError('invalid_audio_request', 400);
+            const input = parsed.data;
+            const scoreDocument = input.document && typeof input.document === 'object' && 'format' in input.document && input.document.format === 'playcraft.score';
+            const existing = input.target?.kind === 'generation-candidate' ? await assets.read(input.target) : undefined;
+            requireScore(!!scoreDocument || input.path?.endsWith('.pcscore.json') === true
+                || input.target?.kind === 'workspace-file' && input.target.path.endsWith('.pcscore.json') || existing?.document.format === 'playcraft.score');
+            const abort = new AbortController(), cancel = () => abort.abort(), close = () => { if (!response.writableEnded)
+                cancel(); };
+            request.once('aborted', cancel);
+            response.once('close', close);
+            try {
+                const result = await withDirectoryWrite(state, { workspaceId, directoryName, wait: false, sessionId: sessionId ?? undefined }, async () => {
+                    if (await batchDirectoryHeld(state, workspaceId, directoryName))
+                        throw audioError('batch_workspace_readonly', 403);
+                    const path = parsed.data.target && parsed.data.target.kind === 'workspace-file'
+                        ? parsed.data.target.path : parsed.data.action === 'adopt'
+                        ? parsed.data.path ?? `source/audio/${parsed.data.target?.candidateId ?? 'candidate'}.${existing?.document.format === 'playcraft.score' ? 'pcscore' : 'pcaudio'}.json` : undefined;
+                    const execute = () => assets.action(parsed.data, abort.signal);
+                    return path ? state.journal.exclusive(`file:${revisionScope(state, workspaceId, directoryName) ?? 'single'}:${path}`, execute) : execute();
+                });
+                send(response, 200, result);
+            }
+            finally {
+                request.off('aborted', cancel);
+                response.off('close', close);
+            }
+            return true;
+        }
+        throw audioError('method_not_allowed', 405);
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' ? error.code :
+            error instanceof Error && /^[a-z][a-z0-9_]+$/.test(error.message) ? error.message : 'audio_request_failed';
+        const status = error && typeof error === 'object' && 'status' in error && typeof error.status === 'number' ? error.status :
+            code === 'directory_busy' || code === 'protected_range_changed' ? 409 : /invalid|unsupported|budget/.test(code) ? 400 : 500;
+        send(response, status, { error: code });
+        return true;
+    }
+}

package/dist/workspace-runtime/server/audio-export.js

@@ -0,0 +1,136 @@
+import { createReadStream } from 'node:fs';
+import { mkdtemp, open, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { WORKSPACE_AUDIO_EXPORT_MAX_BYTES, WORKSPACE_AUDIO_EXPORT_MAX_SECONDS, WORKSPACE_AUDIO_EXPORT_MIME_TYPES, workspaceAudioExportOptionsSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { exportAudio, getAudioInfo } from '../../utils/audio-processor.js';
+let activeExports = 0;
+/** Transcoding is temporary; saving the result uses the normal managed binary write. */
+export async function serveAudioExport(request, response, url) {
+    const json = (status, error) => {
+        if (response.destroyed || response.headersSent)
+            return;
+        response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+        response.end(JSON.stringify({ error }));
+    };
+    const query = Object.fromEntries([...url.searchParams].filter(([name]) => !['workspaceId', 'directoryName'].includes(name)));
+    const parsed = workspaceAudioExportOptionsSchema.safeParse(query);
+    if (!parsed.success || request.headers['content-type']?.split(';')[0]?.trim() !== 'application/octet-stream') {
+        json(400, 'audio_export_invalid_options');
+        return;
+    }
+    const declaredSize = Number(request.headers['content-length']);
+    if (declaredSize > WORKSPACE_AUDIO_EXPORT_MAX_BYTES) {
+        json(413, 'audio_export_input_too_large');
+        request.resume();
+        return;
+    }
+    if (activeExports >= 2) {
+        json(429, 'audio_export_busy');
+        request.resume();
+        return;
+    }
+    activeExports++;
+    const abort = new AbortController();
+    const cancel = () => {
+        abort.abort();
+        if (!request.complete)
+            request.destroy();
+    };
+    const close = () => { if (!response.writableEnded)
+        cancel(); };
+    request.once('aborted', cancel);
+    response.once('close', close);
+    const timeout = setTimeout(cancel, 120_000);
+    timeout.unref();
+    let directory;
+    try {
+        directory = await mkdtemp(join(tmpdir(), 'playcraft-audio-export-'));
+        const input = join(directory, 'input.bin');
+        // private: temporary transcoding input belongs to this controller request.
+        const file = await open(input, 'wx', 0o600);
+        let size = 0;
+        try {
+            for await (const chunk of request.iterator({ destroyOnReturn: false })) {
+                abort.signal.throwIfAborted();
+                const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                size += bytes.length;
+                if (size > WORKSPACE_AUDIO_EXPORT_MAX_BYTES) {
+                    json(413, 'audio_export_input_too_large');
+                    request.resume();
+                    return;
+                }
+                await file.writeFile(bytes);
+            }
+        }
+        finally {
+            await file.close();
+        }
+        if (!size) {
+            json(400, 'audio_export_empty_input');
+            return;
+        }
+        const info = await getAudioInfo(input);
+        if (!Number.isFinite(info.duration) || info.duration <= 0) {
+            json(400, 'audio_export_invalid_input');
+            return;
+        }
+        if (info.duration > WORKSPACE_AUDIO_EXPORT_MAX_SECONDS) {
+            json(400, 'audio_export_too_long');
+            return;
+        }
+        const { targetBytes, ...options } = parsed.data;
+        const output = join(directory, `audio.${options.format}`);
+        const result = await exportAudio(input, output, {
+            ...options, channels: options.channels,
+            ...(targetBytes === undefined ? {} : { targetSize: `${targetBytes}B` }), signal: abort.signal,
+        });
+        if (result.fileSize > WORKSPACE_AUDIO_EXPORT_MAX_BYTES) {
+            json(413, 'audio_export_output_too_large');
+            return;
+        }
+        if (targetBytes !== undefined && result.fileSize > targetBytes) {
+            json(422, 'audio_export_target_size_unreachable');
+            return;
+        }
+        abort.signal.throwIfAborted();
+        response.writeHead(200, {
+            'content-type': WORKSPACE_AUDIO_EXPORT_MIME_TYPES[options.format],
+            'content-length': result.fileSize,
+            'content-disposition': `attachment; filename="audio.${options.format}"`,
+            'cache-control': 'private, no-store', 'x-content-type-options': 'nosniff',
+        });
+        await pipeline(createReadStream(output), response, { signal: abort.signal });
+    }
+    catch (error) {
+        if (response.headersSent)
+            response.destroy(error instanceof Error ? error : undefined);
+        else {
+            const detail = error instanceof Error ? error.message : '';
+            const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+            if (abort.signal.aborted)
+                json(408, 'audio_export_cancelled');
+            else if (/target.*size|target.*budget|budget.*small/i.test(`${code} ${detail}`))
+                json(422, 'audio_export_target_size_unreachable');
+            else if (/encoder.*(unavailable|not found)|unknown encoder|cannot find ffmpeg/i.test(`${code} ${detail}`))
+                json(503, 'audio_export_encoder_unavailable');
+            else if (/invalid.*option|unsupported.*(format|rate|bitrate|channel)/i.test(`${code} ${detail}`))
+                json(400, 'audio_export_invalid_options');
+            else
+                json(422, 'audio_export_failed');
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+        request.off('aborted', cancel);
+        response.off('close', close);
+        try {
+            if (directory)
+                await rm(directory, { recursive: true, force: true });
+        }
+        finally {
+            activeExports--;
+        }
+    }
+}