@playcraft/cli 0.1.49-beta → 0.1.50-beta

package/dist/workspace-runtime/previews/publish.js

@@ -12,6 +12,7 @@ import { classifyPreviewOutput, findExternalLocalReferences } from './single-fil
 import { saveWorkspacePlayableOutput } from './output.js';
 import { injectPreviewDiagnostics } from './diagnostics.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
+import { prepareRuntimePreview, RuntimePreviewBuildError } from './runtime-preview.js';
 const BUILD_TIMEOUT_MS = 10 * 60_000;
 /** Build output and the builder's own scratch folder live in the checkout, hidden from Git. */
 const OUTPUT_FOLDER = '.playcraft-preview-out';
@@ -78,17 +79,23 @@ export async function runPreviewPublish(state, operation, root) {
     await operationLog.append(operation.operationId, `$ preview build\n`).catch(() => undefined);
     try {
         await ensureDependencies(state, revisionScope(state, workspaceId, operation.directoryName) ?? workspaceId, root, output);
+        const runtimePreview = await prepareRuntimePreview(state, operation, root);
+        if (runtimePreview)
+            await excludeFromGit(root, '/.playcraft-editor-preview/');
         await excludeFromGit(root, `/${OUTPUT_FOLDER}/`);
         await excludeFromGit(root, `/${BUILDER_TEMP_FOLDER}/`);
         await excludeFromGit(root, `/${WORKSPACE_ARTIFACT_OUTPUT_DIRECTORY}/`);
-        await buildPreview(state, root, outputDir, operation.operationId, output, appendLog);
-        const bytes = injectPreviewDiagnostics(await readSingleHtml(outputDir));
+        await buildPreview(state, root, outputDir, operation.operationId, output, appendLog, runtimePreview?.command);
+        const runtimeBuild = runtimePreview ? await runtimePreview.finish() : undefined;
+        const built = runtimeBuild?.bytes ?? await readSingleHtml(outputDir);
+        const bytes = injectPreviewDiagnostics(built);
         if (bytes.byteLength > PREVIEW_HTML_MAX_BYTES)
             throw new PreviewFailure('preview_not_single_file');
         if (findExternalLocalReferences(bytes.toString('utf8')).length > 0) {
             throw new PreviewFailure('preview_not_single_file');
         }
-        await saveWorkspacePlayableOutput(root, bytes);
+        if (!runtimePreview)
+            await saveWorkspacePlayableOutput(root, bytes);
         const contentDigest = createHash('sha256').update(bytes).digest('hex');
         const contentMd5 = createHash('md5').update(bytes).digest('base64');
         const source = await sourceRevision(root);
@@ -132,7 +139,9 @@ export async function runPreviewPublish(state, operation, root) {
             logTail: tail(output.log),
         }));
         if (published.sessionId !== operation.sessionId || published.previewId !== reserved.previewId ||
-            published.artifactId !== reserved.artifactId) {
+            published.artifactId !== reserved.artifactId ||
+            published.contentDigest !== contentDigest ||
+            (runtimeBuild && JSON.stringify(published.runtimeParameters) !== JSON.stringify(runtimeBuild.profile))) {
             throw new PreviewFailure('preview_scope_mismatch');
         }
         if (published.status === 'conflict')
@@ -140,7 +149,7 @@ export async function runPreviewPublish(state, operation, root) {
         return published;
     }
     catch (error) {
-        const code = error instanceof PreviewFailure ? error.code : 'preview_build_failed';
+        const code = error instanceof PreviewFailure || error instanceof RuntimePreviewBuildError ? error.code : 'preview_build_failed';
         appendLog(`\n[${code}] ${error instanceof Error ? error.message : code}\n`);
         if (code !== 'publish_conflict') {
             await postControl(state, '/runtime/internal/preview-failures', {
@@ -180,13 +189,13 @@ async function ensureDependencies(state, workspaceId, root, output) {
         throw new PreviewFailure('dependencies_not_ready');
     }
 }
-async function buildPreview(state, root, outputDir, operationId, output, onLog) {
+async function buildPreview(state, root, outputDir, operationId, output, onLog, runtimeCommand) {
     // Tests replace the build; the real one needs a project and the published CLI.
     const planned = process.env.PLAYCRAFT_PREVIEW_BUILD_COMMAND || BUILD_COMMAND;
     const outcome = await runDeveloperCommand(state, {
         processId: `preview-${operationId}`,
         cwd: root,
-        command: `${planned} --output ${shellQuote(outputDir)} .`,
+        command: runtimeCommand ?? `${planned} --output ${shellQuote(outputDir)} .`,
         timeoutMs: BUILD_TIMEOUT_MS,
         onOutput: (chunk) => {
             const text = String(chunk);

package/dist/workspace-runtime/previews/runtime-preview.js

@@ -0,0 +1,177 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, readFile, realpath, rm } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+import JSON5 from 'json5';
+import { z } from 'zod';
+import { embedWorkspaceRuntimeProfile, workspaceRelativePathSchema, workspaceRuntimePreviewProfileSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { readWorkspaceParameters } from '../workspaces/parameters.js';
+import { revisionScope } from '../workspaces/registry.js';
+const manifestPath = '.playcraft/workspace.json';
+const digest = (value) => createHash('sha256').update(value).digest('hex');
+const relativePath = z
+    .string()
+    .refine((path) => workspaceRelativePathSchema.safeParse(path).success);
+const configSchema = z
+    .object({
+    version: z.literal(1),
+    buildScript: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9:_-]{0,63}$/),
+    outputPath: relativePath.refine((path) => path.startsWith('.playcraft-editor-preview/') && path.endsWith('.html')),
+    reportPath: relativePath.refine((path) => path.startsWith('.playcraft-editor-preview/') && path.endsWith('.json')),
+    configContractVersion: z.string().min(1).max(128),
+    gameFilePaths: z.array(relativePath).max(256).default([]),
+})
+    .strict();
+const reportSchema = z
+    .object({
+    target: z.literal('editor-static'),
+    buildId: z.string(),
+    htmlDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    schemaDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    sourceFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+    dataHash: z.string().regex(/^[a-f0-9]{64}$/),
+    dataRevision: z.number().int().nonnegative(),
+    schemaRevision: z.number().int().nonnegative(),
+    moduleIds: z.array(z.string()).min(1).max(10000),
+})
+    .strict();
+export class RuntimePreviewBuildError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+async function insideFile(root, path) {
+    const base = await realpath(root);
+    const file = await isolatedPath(root, path);
+    const real = await realpath(file);
+    const rel = relative(base, real);
+    const stat = await lstat(file);
+    if (!stat.isFile() ||
+        stat.isSymbolicLink() ||
+        rel === '..' ||
+        rel.startsWith(`..${sep}`) ||
+        stat.size > 50 * 1024 * 1024)
+        throw new RuntimePreviewBuildError('runtime_preview_path_invalid');
+    return readFile(file);
+}
+async function isolatedPath(root, path) {
+    const normalized = workspaceRelativePathSchema.parse(path);
+    const base = await realpath(root);
+    let parent = base;
+    for (const segment of normalized.split('/').slice(0, -1)) {
+        parent = resolve(parent, segment);
+        const stat = await lstat(parent).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
+            throw new RuntimePreviewBuildError('runtime_preview_path_invalid');
+    }
+    return resolve(base, normalized);
+}
+export async function prepareRuntimePreview(state, operation, root) {
+    let manifest;
+    try {
+        manifest = await insideFile(root, manifestPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    let declared;
+    try {
+        declared = JSON5.parse(manifest.toString()).previewRuntime;
+    }
+    catch {
+        throw new RuntimePreviewBuildError('runtime_preview_manifest_invalid');
+    }
+    if (declared === undefined)
+        return undefined;
+    const parsed = configSchema.safeParse(declared);
+    if (!parsed.success)
+        throw new RuntimePreviewBuildError('runtime_preview_manifest_invalid');
+    const config = parsed.data;
+    const packageData = JSON.parse((await insideFile(root, 'package.json')).toString());
+    if (typeof packageData.scripts?.[config.buildScript] !== 'string')
+        throw new RuntimePreviewBuildError('runtime_preview_script_missing');
+    const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
+    const read = () => readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    const before = await read();
+    if (before.status !== 'ready' ||
+        !before.schemaHash ||
+        !before.dataHash ||
+        !before.sourceFingerprint)
+        throw new RuntimePreviewBuildError('runtime_preview_parameters_missing');
+    const gameHashes = await Promise.all([...new Set(['package.json', ...config.gameFilePaths])].map(async (path) => [path, digest(await insideFile(root, path))]));
+    const buildId = randomUUID();
+    const profileBase = {
+        version: 1,
+        target: 'editor-static',
+        protocolVersion: 1,
+        binding: {
+            scope: {
+                projectId: operation.workspaceId,
+                branchName: operation.directoryName ?? 'basic',
+                themeId: before.themeId ?? 'default',
+            },
+            schemaVersion: before.schemaHash,
+            configContractVersion: config.configContractVersion,
+            locale: 'en',
+        },
+        sourceFingerprint: before.sourceFingerprint,
+        baseline: {
+            dataRevision: before.dataRevision ?? 0,
+            schemaRevision: before.schemaRevision ?? 0,
+            dataHash: before.dataHash,
+        },
+    };
+    const context = { buildId, ...profileBase };
+    // Remove stale outputs before the script runs; a stale report cannot satisfy this build's identity.
+    for (const path of [config.outputPath, config.reportPath]) {
+        await rm(await isolatedPath(root, path), { force: true });
+    }
+    return {
+        command: `PLAYCRAFT_RUNTIME_PREVIEW_CONTEXT=${shellQuote(JSON.stringify(context))} pnpm run ${shellQuote(config.buildScript)}`,
+        async finish() {
+            const after = await read();
+            if (after.status !== 'ready' ||
+                after.sourceFingerprint !== before.sourceFingerprint ||
+                after.dataHash !== before.dataHash ||
+                after.schemaHash !== before.schemaHash ||
+                after.dataRevision !== before.dataRevision ||
+                after.schemaRevision !== before.schemaRevision ||
+                digest(await insideFile(root, manifestPath)) !== digest(manifest))
+                throw new RuntimePreviewBuildError('runtime_preview_source_changed');
+            for (const [path, hash] of gameHashes) {
+                if (digest(await insideFile(root, path)) !== hash)
+                    throw new RuntimePreviewBuildError('runtime_preview_source_changed');
+            }
+            const bytes = await insideFile(root, config.outputPath);
+            const report = reportSchema.safeParse(JSON.parse((await insideFile(root, config.reportPath)).toString()));
+            if (!report.success ||
+                report.data.buildId !== buildId ||
+                report.data.htmlDigest !== digest(bytes) ||
+                report.data.schemaDigest !== before.schemaHash ||
+                report.data.sourceFingerprint !== before.sourceFingerprint ||
+                report.data.dataHash !== before.dataHash ||
+                report.data.dataRevision !== before.dataRevision ||
+                report.data.schemaRevision !== before.schemaRevision ||
+                !report.data.moduleIds.some((id) => /(?:@playcraft\/preview-runtime|\/preview-runtime\/src\/(?:preview|runtime)\.ts)/.test(id)))
+                throw new RuntimePreviewBuildError('runtime_preview_report_invalid');
+            const profile = workspaceRuntimePreviewProfileSchema.parse({
+                ...profileBase,
+                buildDigest: report.data.htmlDigest,
+            });
+            return {
+                bytes: Buffer.from(embedWorkspaceRuntimeProfile(bytes.toString(), profile)),
+                profile,
+            };
+        },
+    };
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/workspace-runtime/serve.js

@@ -3,12 +3,13 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readdir } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { createPlatformAdapter } from '@playcraft/build';
-import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, transitionOperation, directoryMutationReceiptSchema, productionSessionAttemptId, } from '@playcraft/common/cloud-workspace/runtime';
 import { RuntimeJournal } from './persistence/journal.js';
 import { createCodexAppServerAdapter } from './codex/app-server.js';
 import { trustedMemberPolicy } from './batch/policy.js';
+import { batchDirectoryHeld } from './batch/occupancy.js';
 import { createLoopbackNativeAdapter } from './codex/loopback.js';
-import { attachNativeCollector } from './server/dispatch.js';
+import { attachNativeCollector, recoverInterruptedParameterVerifications, stopParameterVerifications } from './server/dispatch.js';
 import { handleRuntimeRequest } from './server/http.js';
 import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
 import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
@@ -23,6 +24,9 @@ import { DeliveryStore, recoverInterruptedDeliveries } from './workspaces/delive
 import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
 import { workspaceContextFromRoot, workspaceRoot } from './workspaces/registry.js';
 import { recoverInterruptedLibraryImports } from './workspaces/asset-library-import.js';
+import { recoverAssetTransfers } from './workspaces/asset-transfer-publish.js';
+import { recoverWorkspaceDirectoryMutation } from './workspaces/directory-mutations.js';
+import { observeWorkspaceDirectories } from './workspaces/directory-revisions.js';
 import { observeWorkspaceBinaryFile } from './workspaces/binary-write.js';
 import { revisionScope } from './workspaces/registry.js';
 import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
@@ -52,6 +56,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const previousIdentityMatches = journal.epochsSnapshot().some((epoch) => epoch.runtime_id === config.runtimeId && epoch.generation === config.generation && epoch.runtime_epoch === previousEpoch);
         await recoverInterruptedInstalls(journal);
         await recoverInterruptedPreviews(journal);
+        await recoverInterruptedParameterVerifications(journal);
         await recoverInterruptedDeliveries(config.stateDir);
         await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
         const state = runtimeState = {
@@ -67,6 +72,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         };
         const recoveredImports = new Map();
         const recoveredChanges = [];
+        const recoveredWrites = [];
         const recoverLibraryImports = async (root) => {
             const result = await recoverInterruptedLibraryImports(root).catch(() => undefined);
             for (const published of result?.published ?? []) {
@@ -95,7 +101,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             if (operation.kind !== 'asset.library.import' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
             const published = recoveredImports.get(operation.operationId);
-            const result = operation.result ? { ...operation.result,
+            const result = operation.result && 'paths' in operation.result ? { ...operation.result,
                 paths: [...new Set([...operation.result.paths, ...(published?.paths ?? [])])],
                 failures: operation.result.failures.filter(failure => !published?.assetIds.includes(failure.assetId)),
             } : undefined;
@@ -124,16 +130,107 @@ export async function startWorkspaceRuntime(config, options = {}) {
                 recoveredChanges.push({ workspaceId: operation.workspaceId,
                     directoryName: operation.directoryName ?? 'basic', paths: result.paths });
         }
+        const recoveredBundles = new Map();
+        const transferScopes = new Set();
+        for (const { operation } of journal.listOperations()) {
+            if (operation.kind !== 'asset.bundle.save')
+                continue;
+            const directoryName = operation.directoryName ?? 'basic';
+            const key = `${operation.workspaceId ?? ''}:${directoryName}`;
+            if (transferScopes.has(key))
+                continue;
+            transferScopes.add(key);
+            const root = await workspaceRoot(state, operation.workspaceId, directoryName).catch(() => undefined);
+            if (!root)
+                continue;
+            const recovered = await recoverAssetTransfers(root, { environment: config.environment, userId: config.userId,
+                workspaceId: operation.workspaceId ?? '', directoryName }).catch(() => []);
+            for (const item of recovered)
+                recoveredBundles.set(item.operationId, item);
+        }
+        for (const { scopeKey, operation } of journal.listOperations()) {
+            if (operation.kind !== 'asset.bundle.save' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
+                continue;
+            const recovered = recoveredBundles.get(operation.operationId), receipt = recovered?.receipt;
+            let next = operation;
+            if (receipt) {
+                const paths = [...receipt.files.map(file => file.path), ...(receipt.directories ?? [])];
+                const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
+                for (const file of receipt.files) {
+                    const previous = journal.fileRevisions(scope)[file.path];
+                    const revision = previous ? previous.revision + (previous.contentHash === file.contentHash ? 0 : 1) : 1;
+                    await journal.putFileRevision(file.path, { revision,
+                        contentHash: file.contentHash }, scope);
+                    const metadata = recovered?.manifest.files.find(item => item.path === file.path);
+                    recoveredWrites.push({ ...file, revision, writer: 'manual', workspaceId: operation.workspaceId,
+                        directoryName: operation.directoryName ?? 'basic', operationId: operation.operationId, transferId: receipt.transferId,
+                        ...(metadata?.processing ? { processing: metadata.processing } : {}), recovered: true });
+                }
+                if (next.status === 'queued')
+                    next = transitionOperation(next, 'dispatched');
+                if (next.status === 'dispatched')
+                    next = transitionOperation(next, 'accepted');
+                next = transitionOperation(next, 'completed', { result: { paths, skippedPaths: [], failures: [], bundleReceipt: receipt } });
+                if (operation.workspaceId)
+                    recoveredChanges.push({ workspaceId: operation.workspaceId, directoryName: operation.directoryName ?? 'basic', paths, source: 'asset.bundle.save' });
+            }
+            else
+                next = transitionOperation(next, 'failed', { error: 'asset_bundle_save_interrupted' });
+            await journal.putOperation(scopeKey, next);
+        }
+        for (const { scopeKey, operation } of journal.listOperations()) {
+            if (!['directory.rename', 'directory.delete'].includes(operation.kind)
+                || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
+                continue;
+            const kind = operation.kind;
+            let next = operation;
+            try {
+                const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
+                const receipt = await recoverWorkspaceDirectoryMutation(root, kind, { operationId: operation.operationId,
+                    operationPayloadHash: operation.payloadHash, scope: scopeKey, assertCurrent: async () => {
+                        if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
+                            throw new Error('stale_lease');
+                        if (operation.sessionId && productionSessionAttemptId(operation.sessionId))
+                            throw new Error('production_session_readonly');
+                        if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
+                            throw new Error('batch_workspace_readonly');
+                    } });
+                if (!receipt)
+                    throw new Error('directory_mutation_interrupted');
+                await observeWorkspaceDirectories(root, journal, revisionScope(state, operation.workspaceId, operation.directoryName));
+                const paths = [receipt.path, ...(receipt.newPath ? [receipt.newPath] : [])];
+                if (next.status === 'queued')
+                    next = transitionOperation(next, 'dispatched');
+                if (next.status === 'dispatched')
+                    next = transitionOperation(next, 'accepted');
+                next = transitionOperation(next, 'completed', { result: { paths, skippedPaths: [], failures: [], directoryMutation: directoryMutationReceiptSchema.parse(receipt) } });
+                if (operation.workspaceId)
+                    recoveredChanges.push({ workspaceId: operation.workspaceId,
+                        directoryName: operation.directoryName ?? 'basic', paths, source: kind });
+            }
+            catch (error) {
+                const reason = String(error?.code ?? (error instanceof Error ? error.message : ''));
+                const code = ['directory_mutation_interrupted', 'stale_lease', 'production_session_readonly', 'batch_workspace_readonly',
+                    'directory_exists', 'directory_not_found', 'revision_conflict', 'directory_conflict', 'invalid_workspace_path', 'workspace_permission_denied']
+                    .includes(reason) ? reason : 'directory_recovery_required';
+                next = transitionOperation(next, code === 'directory_mutation_interrupted' ? 'failed' : 'uncertain', { error: code });
+            }
+            await journal.putOperation(scopeKey, next);
+        }
         const native = state.native ??= defaultNativeAdapter(state);
         await journal.bindRuntime({
             runtimeId: config.runtimeId,
             generation: config.generation,
             runtimeEpoch: state.runtimeEpoch,
         });
+        for (const payload of recoveredWrites)
+            await journal.allocateSourceEvent({ runtimeId: config.runtimeId,
+                generation: config.generation, runtimeEpoch: state.runtimeEpoch, workspaceId: payload.workspaceId,
+                type: 'file.written', occurredAt: new Date().toISOString(), payload });
         for (const change of recoveredChanges)
             await journal.allocateSourceEvent({ runtimeId: config.runtimeId,
                 generation: config.generation, runtimeEpoch: state.runtimeEpoch, workspaceId: change.workspaceId,
-                type: 'files.changed', occurredAt: new Date().toISOString(), payload: { ...change, source: 'asset.library.import', recovered: true },
+                type: 'files.changed', occurredAt: new Date().toISOString(), payload: { ...change, source: change.source ?? 'asset.library.import', recovered: true },
             });
         startSourceEventUploader(state);
         if (config.workspaceMode === 'multi') {
@@ -198,6 +295,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             url: `http://${formatHost(config.listen.host)}:${port}`,
             async close() {
                 const serverClosed = closeServer(server);
+                await stopParameterVerifications(state);
                 await closeCliCredentials(state);
                 await gitCredentials?.close();
                 try {

package/dist/workspace-runtime/server/asset-transfers.js

@@ -0,0 +1,63 @@
+import { ASSET_TRANSFER_BODY_MAX_BYTES, ASSET_TRANSFER_CHUNK_BODY_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
+import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
+import { AssetTransferError, cancelAssetTransfer, createAssetTransfer, getAssetTransfer, putAssetTransferChunk } from '../workspaces/asset-transfer-storage.js';
+export async function handleAssetTransferRequest(state, request, url) {
+    const route = /^\/runtime\/asset-transfers(?:\/([^/]+)(?:\/(chunks))?)?$/.exec(url.pathname);
+    if (!route)
+        return undefined;
+    const workspaceId = url.searchParams.get('workspaceId') ?? '';
+    const directoryName = url.searchParams.get('directoryName') ?? 'basic';
+    try {
+        if (state.journal.destroyed())
+            throw new AssetTransferError('runtime_destroyed');
+        if (!/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
+            throw new AssetTransferError('invalid_workspace_directory', 400);
+        const [, id, action] = route;
+        const valid = !id && request.method === 'POST' || id && !action && ['GET', 'DELETE'].includes(request.method ?? '')
+            || id && action === 'chunks' && request.method === 'PUT';
+        if (!valid)
+            return { status: 405, body: { error: 'asset_transfer_method_not_allowed' } };
+        const scope = { workspaceId, directoryName, environment: state.config.environment, userId: state.config.userId };
+        const body = ['POST', 'PUT'].includes(request.method ?? '')
+            ? await readTransferJson(request, action ? ASSET_TRANSFER_CHUNK_BODY_MAX_BYTES : ASSET_TRANSFER_BODY_MAX_BYTES) : undefined;
+        return await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => state.journal.exclusive(`workspace:${revisionScope(state, workspaceId, directoryName) ?? 'single'}`, async () => {
+            if (state.journal.destroyed())
+                throw new AssetTransferError('runtime_destroyed');
+            if (request.method !== 'GET' && await batchDirectoryHeld(state, workspaceId, directoryName))
+                throw new AssetTransferError('batch_workspace_readonly');
+            const root = await workspaceRoot(state, workspaceId, directoryName);
+            const result = !id ? await createAssetTransfer(root, scope, body)
+                : action ? await putAssetTransferChunk(root, scope, id, body)
+                    : request.method === 'GET' ? await getAssetTransfer(root, scope, id) : await cancelAssetTransfer(root, scope, id);
+            return { status: 200, body: result };
+        }));
+    }
+    catch (error) {
+        if (error instanceof AssetTransferError)
+            return { status: error.status, body: { error: error.code } };
+        if (error.name === 'ZodError')
+            return { status: 400, body: { error: 'invalid_asset_transfer' } };
+        throw error;
+    }
+}
+async function readTransferJson(request, limit) {
+    const length = request.headers['content-length'];
+    if (length && (!/^\d+$/.test(length) || Number(length) > limit))
+        throw new AssetTransferError('asset_transfer_too_large', 413);
+    const parts = [];
+    let size = 0;
+    for await (const data of request) {
+        const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        size += bytes.length;
+        if (size > limit)
+            throw new AssetTransferError('asset_transfer_too_large', 413);
+        parts.push(bytes);
+    }
+    try {
+        return JSON.parse(Buffer.concat(parts).toString('utf8'));
+    }
+    catch {
+        throw new AssetTransferError('invalid_asset_transfer', 400);
+    }
+}