@playcraft/cli 0.1.48-beta → 0.1.50-beta

package/dist/workspace-runtime/batch/source-capture.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, open, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative } from 'node:path';
 import { gzip, gunzip } from 'node:zlib';
 import { promisify } from 'node:util';
@@ -29,18 +29,10 @@ export function digestFiles(files) {
         hash.update(path).update('\0').update(String(file.mode)).update('\0').update(file.body).update('\0');
     return hash.digest('hex');
 }
-/** Working tree plus exact skill artifacts. Credentials, caches and node_modules are left out. */
+/** Files Git will accept. Credentials, caches and node_modules are left out. */
 export async function readSourceFiles(root) {
     const source = await realpath(root);
     const paths = new Set((await gitRead(source, ['ls-files', '--cached', '--others', '--exclude-standard', '-z'])).split('\0').filter(Boolean));
-    const artifacts = await readdir(join(source, '.playcraft/skill-artifacts')).catch(error => {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    });
-    for (const name of artifacts)
-        if (/^[a-f0-9]{64}\.tar\.gz$/.test(name))
-            paths.add(`.playcraft/skill-artifacts/${name}`);
     const files = new Map();
     for (const path of [...paths].sort()) {
         if (!included(path))
@@ -57,12 +49,7 @@ export async function readSourceFiles(root) {
             throw new Error('batch_source_path_invalid');
         const handle = await open(full, constants.O_RDONLY | constants.O_NOFOLLOW);
         try {
-            const body = await handle.readFile();
-            if (/^\.playcraft\/skill-artifacts\/[a-f0-9]{64}\.tar\.gz$/.test(path)
-                && createHash('sha256').update(body).digest('hex') !== path.slice(path.lastIndexOf('/') + 1, -7)) {
-                throw new Error('batch_source_path_invalid');
-            }
-            files.set(path, { body, mode: snapshotMode(stat.mode) });
+            files.set(path, { body: await handle.readFile(), mode: snapshotMode(stat.mode) });
         }
         finally {
             await handle.close();
@@ -92,7 +79,7 @@ export async function captureIndependentSource(source, destination) {
     const headBefore = await gitRead(root, ['rev-parse', '--verify', 'HEAD']).catch(() => '');
     let files = await readSourceFiles(root);
     files = await filterUnstableFiles(root, files);
-    const digest = digestFiles(files);
+    const contentDigest = digestFiles(files);
     const staging = join(dirname(destination), `.batch-source-${randomUUID()}`);
     try {
         await mkdir(staging, { recursive: true });
@@ -107,7 +94,7 @@ export async function captureIndependentSource(source, destination) {
         if (headBefore !== await gitRead(root, ['rev-parse', '--verify', 'HEAD']).catch(() => ''))
             throw new Error('batch_source_changed');
         const after = await filterUnstableFiles(root, await readSourceFiles(root));
-        if (digestFiles(after) !== digest)
+        if (digestFiles(after) !== contentDigest)
             throw new Error('batch_source_changed');
         await excludeFromGit(staging);
         await excludeFromGit(staging, '/.env*');
@@ -117,7 +104,7 @@ export async function captureIndependentSource(source, destination) {
         await gitWrite(staging, ['commit', '--allow-empty', '-m', 'Freeze batch source']);
         const commitHash = (await gitWrite(staging, ['rev-parse', 'HEAD'])).trim();
         await rename(staging, destination);
-        return { commitHash, digest };
+        return { commitHash, digest: commitHash };
     }
     finally {
         await rm(staging, { recursive: true, force: true });
@@ -145,7 +132,7 @@ export async function restoreArchive(body, destination, expectedDigest) {
         await writeFile(bundle, Buffer.from(archive.bundle, 'base64'), { mode: 0o600 });
         await gitWrite(temporary, ['clone', '--no-checkout', '--', bundle, destination]);
         await gitWrite(destination, ['checkout', '--detach', archive.commitHash]);
-        if (digestFiles(await readSourceFiles(destination)) !== expectedDigest)
+        if ((await gitRead(destination, ['rev-parse', 'HEAD'])).trim() !== archive.commitHash)
             throw new Error('batch_snapshot_mismatch');
         return { commitHash: archive.commitHash };
     }

package/dist/workspace-runtime/batch/source-publish.js

@@ -1,16 +1,14 @@
 import { lstat, mkdir, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { copyCredentialHelpers, gitRead, gitWrite } from './git.js';
-import { archiveSource, digestFiles, readSourceFiles, restoreArchive } from './source-capture.js';
+import { archiveSource, restoreArchive } from './source-capture.js';
 import { sourceCacheDir } from './records.js';
 import { BatchSourceFreezeError, sourceFreezeError } from './source-failure.js';
 async function reject(state, candidate, code, stage, retryable, outcome, cause) {
     throw await sourceFreezeError(state, candidate.snapshot.batchId, { code, stage, retryable, outcome }, cause);
 }
 async function verifyCache(cache, candidate) {
-    if ((await gitRead(cache, ['rev-parse', '--verify', 'HEAD']).catch(() => '')).trim() !== candidate.snapshot.commitHash)
-        return false;
-    return digestFiles(await readSourceFiles(cache)) === candidate.snapshot.digest;
+    return (await gitRead(cache, ['rev-parse', '--verify', 'HEAD']).catch(() => '')).trim() === candidate.snapshot.commitHash;
 }
 function pushFailureCode(error) {
     const detail = error;

package/dist/workspace-runtime/codex/app-server.js

@@ -17,6 +17,7 @@ import { nativeMcpConfig } from './mcp-config.js';
 import { requestNativeCompaction } from './compact.js';
 import { readNativeThreadImage } from './thread-image.js';
 import { WORKSPACE_UI_TOOLS, WorkspaceUiTools } from './ui-tools.js';
+import { WORKSPACE_DELIVERY_TOOLS, WorkspaceDeliveryTools, isWorkspaceDeliveryTool } from './delivery-tools.js';
 import { WORKSPACE_UI_INSTRUCTIONS } from './ui-instructions.js';
 function withModelShell(config, modelConfigId) {
     if (!modelConfigId || !/^[0-9a-f-]{36}$/i.test(modelConfigId))
@@ -103,6 +104,11 @@ export function createCodexAppServerAdapter(options) {
     const collected = new Set();
     const coordinatorDirectories = new Map();
     const uiTools = new WorkspaceUiTools(emitCollected, options.uiToolTimeoutMs);
+    const deliveryTools = options.deliveryTools ? new WorkspaceDeliveryTools(options.deliveryTools) : undefined;
+    const dynamicTools = [
+        ...(options.workspaceUi ? WORKSPACE_UI_TOOLS : []),
+        ...(deliveryTools ? WORKSPACE_DELIVERY_TOOLS : []),
+    ];
     function emitCollected(event) {
         for (const listener of collected)
             listener(event);
@@ -474,6 +480,16 @@ export function createCodexAppServerAdapter(options) {
             const payload = asRecord(params);
             if (method === 'item/tool/call') {
                 const thread = typeof payload.threadId === 'string' ? threads.get(payload.threadId) : undefined;
+                if (deliveryTools && isWorkspaceDeliveryTool(payload.tool)) {
+                    void deliveryTools.request(id, payload, nativeClient, {
+                        sessionId: thread?.sessionId,
+                        cwd: thread?.cwd,
+                        workspaceId: thread?.uiSnapshot?.workspaceId,
+                        directoryName: thread?.uiSnapshot?.directoryName,
+                        readOnly: thread?.readOnlyConfirmed === true || thread?.permissionMode === 'read-only',
+                    });
+                    return;
+                }
                 uiTools.request(id, payload, nativeClient, options.workspaceUi && thread?.turnActive
                     && payload.turnId === thread.lastTurnId ? thread.uiSnapshot : undefined);
                 return;
@@ -678,7 +694,7 @@ export function createCodexAppServerAdapter(options) {
                 const result = await rpc.request('thread/start', {
                     model,
                     ...prepared.params,
-                    ...(options.workspaceUi ? { dynamicTools: WORKSPACE_UI_TOOLS } : {}),
+                    ...(dynamicTools.length ? { dynamicTools } : {}),
                 });
                 const threadId = result.thread?.id;
                 if (!threadId)
@@ -701,6 +717,8 @@ export function createCodexAppServerAdapter(options) {
                 try {
                     const resumed = await rpc.request('thread/resume', {
                         threadId: input.threadId, ...prepared.params,
+                        // Resume does not necessarily retain tools supplied to thread/start.
+                        ...(dynamicTools.length ? { dynamicTools } : {}),
                     }, 30_000);
                     resumedId = resumed.thread?.id;
                     readOnlyConfirmed = isReadOnlySnapshot(resumed);

package/dist/workspace-runtime/codex/delivery-tools.js

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { DELIVERY_CHANNELS, deliveryFormatSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_DELIVERY_TOOLS = [
+    {
+        type: 'function',
+        name: 'playcraft_build_delivery',
+        description: 'Start one formal channel delivery build. Returns build identifiers immediately; poll playcraft_get_delivery for status and validation results. This writes a delivery record under dist/delivery/.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channels: {
+                    type: 'array',
+                    items: { type: 'string', enum: DELIVERY_CHANNELS },
+                    minItems: 1,
+                    maxItems: 8,
+                    uniqueItems: true,
+                },
+                format: { type: 'string', enum: ['html', 'zip'] },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        type: 'function',
+        name: 'playcraft_get_delivery',
+        description: 'Read the latest delivery build, or one build by id, including status, validation summary, error and a truncated build log.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                buildId: { type: 'string' },
+                channel: { type: 'string', enum: DELIVERY_CHANNELS },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+const DELIVERY_TOOL_NAMES = new Set(WORKSPACE_DELIVERY_TOOLS.map(tool => tool.name));
+export function isWorkspaceDeliveryTool(name) {
+    return typeof name === 'string' && DELIVERY_TOOL_NAMES.has(name);
+}
+export class WorkspaceDeliveryTools {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    async request(requestId, payload, client, context) {
+        const tool = typeof payload.tool === 'string' ? payload.tool : '';
+        const args = payload.arguments;
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (!context.sessionId || (!context.cwd && !context.workspaceId)) {
+            await this.reject(client, requestId, 'feature_unavailable');
+            return;
+        }
+        if (context.directoryName === 'root') {
+            await this.reject(client, requestId, 'invalid_workspace_directory');
+            return;
+        }
+        const input = args;
+        if (tool === 'playcraft_build_delivery')
+            return this.build(requestId, payload, input, client, context);
+        if (tool === 'playcraft_get_delivery')
+            return this.get(requestId, input, client, context);
+        await this.reject(client, requestId, 'unknown_delivery_tool');
+    }
+    async build(requestId, payload, input, client, context) {
+        if (context.readOnly) {
+            await this.reject(client, requestId, 'permission_denied');
+            return;
+        }
+        const unknown = Object.keys(input).filter(key => key !== 'channels' && key !== 'format');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const channels = input.channels === undefined ? ['playcraft'] : input.channels;
+        if (!Array.isArray(channels) || channels.length < 1 || channels.length > 8
+            || channels.some(channel => !DELIVERY_CHANNELS.includes(channel))
+            || new Set(channels).size !== channels.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const format = input.format === undefined ? undefined : deliveryFormatSchema.safeParse(input.format);
+        if (format && !format.success) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.build({
+                ...context,
+                clientRequestId: typeof payload.callId === 'string' && payload.callId.length
+                    ? payload.callId
+                    : randomUUID(),
+                channels: channels,
+                ...(format && format.success ? { format: format.data } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async get(requestId, input, client, context) {
+        const unknown = Object.keys(input).filter(key => key !== 'buildId' && key !== 'channel');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.buildId !== undefined && (typeof input.buildId !== 'string'
+            || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(input.buildId))) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.channel !== undefined && !DELIVERY_CHANNELS.includes(input.channel)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.get({
+                ...context,
+                ...(typeof input.buildId === 'string' ? { buildId: input.buildId } : {}),
+                ...(typeof input.channel === 'string' ? { channel: input.channel } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async respond(client, requestId, value) {
+        await client.respond(requestId, { success: true, contentItems: toolContent(value) }).catch(() => undefined);
+    }
+    async reject(client, requestId, reason) {
+        await rejectTool(client, requestId, reason);
+    }
+}
+function errorReason(cause) {
+    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
+        return cause.code;
+    return 'delivery_tool_failed';
+}

package/dist/workspace-runtime/codex/tool-response.js

@@ -0,0 +1,10 @@
+export function toolContent(value) {
+    return [{ type: 'inputText', text: JSON.stringify(value) }];
+}
+/** The App Server treats a failed tool call as content, not a JSON-RPC error. */
+export async function rejectTool(client, requestId, reason) {
+    await client.respond(requestId, {
+        success: false,
+        contentItems: toolContent({ status: 'failed', reason }),
+    }).catch(() => undefined);
+}

package/dist/workspace-runtime/codex/ui-tools.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { workspaceUiCommandSchema, workspaceUiResultSchema, WORKSPACE_UI_COMMAND_EVENT, WORKSPACE_UI_RESULT_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool } from './tool-response.js';
 export const WORKSPACE_UI_TOOLS = [
     { type: 'function', name: 'playcraft_get_ui_context',
         description: 'Read the PlayCraft browser view captured when the user sent this turn. This is a turn-start snapshot, not a live browser observation or visual verification. Only the visible panel target is returned by default; request open tabs only when needed.',
@@ -13,6 +14,13 @@ export const WORKSPACE_UI_TOOLS = [
         description: 'Open an existing preview in the current PlayCraft workspace browser view. Omit identifiers for the latest available preview. Opening does not start a build or verify the rendered appearance.',
         inputSchema: { type: 'object', properties: { artifactId: { type: 'string' }, versionId: { type: 'string' },
                 previewId: { type: 'string' } }, additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_delivery',
+        description: 'Open the delivery panel in the current PlayCraft workspace browser view. Opening does not start or verify a build.',
+        inputSchema: { type: 'object', properties: { channel: { type: 'string' }, buildId: { type: 'string' } },
+            additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_task',
+        description: 'Open the task panel in the current PlayCraft workspace browser view. Opening does not change task state.',
+        inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, additionalProperties: false } },
 ];
 /** Read the saved view locally; browser commands have a separate receipt lifecycle. */
 export class WorkspaceUiTools {
@@ -48,8 +56,12 @@ export class WorkspaceUiTools {
             return;
         }
         const kind = params.tool === 'playcraft_open_file' ? 'open_file'
-            : params.tool === 'playcraft_open_preview' ? 'open_preview' : undefined;
-        const allowed = kind === 'open_file' ? ['path', 'range'] : ['artifactId', 'versionId', 'previewId'];
+            : params.tool === 'playcraft_open_preview' ? 'open_preview'
+                : params.tool === 'playcraft_open_delivery' ? 'open_delivery'
+                    : params.tool === 'playcraft_open_task' ? 'open_task' : undefined;
+        const allowed = kind === 'open_file' ? ['path', 'range']
+            : kind === 'open_preview' ? ['artifactId', 'versionId', 'previewId']
+                : kind === 'open_delivery' ? ['channel', 'buildId'] : ['taskId'];
         if (!kind || Object.keys(args).some(key => !allowed.includes(key))) {
             void this.reject(client, requestId, 'invalid_ui_tool_arguments');
             return;
@@ -98,6 +110,8 @@ export class WorkspaceUiTools {
         if (snapshot && (snapshot.viewId !== command.viewId || snapshot.sessionId !== command.sessionId
             || snapshot.workspaceId !== command.workspaceId || snapshot.directoryName !== command.directoryName))
             return { outcome: 'failed', error: 'ui_result_scope_mismatch' };
+        const targetTab = command.kind === 'open_file' ? 'files'
+            : command.kind === 'open_preview' ? 'preview' : command.kind;
         if (result.status === 'opened' && (!snapshot?.panelOpen
             || (command.kind === 'open_file' && (!isAssetTab(snapshot.activeTab) || snapshot.activeFile?.path !== command.path
                 || (command.range && (snapshot.activeFile.range?.startLine !== command.range.startLine
@@ -105,7 +119,11 @@ export class WorkspaceUiTools {
             || (command.kind === 'open_preview' && (snapshot.activeTab !== 'preview' || !snapshot.activePreview
                 || (command.artifactId && snapshot.activePreview.artifactId !== command.artifactId)
                 || (command.versionId && snapshot.activePreview.versionId !== command.versionId)
-                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))))
+                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))
+            || (command.kind !== 'open_file' && command.kind !== 'open_preview' && snapshot.activeTab !== targetTab)
+            || (command.kind === 'open_delivery' && ((command.channel !== undefined && snapshot.activeDelivery?.channel !== command.channel)
+                || (command.buildId !== undefined && snapshot.activeDelivery?.buildId !== command.buildId)))
+            || (command.kind === 'open_task' && command.taskId !== undefined && snapshot.activeTask?.taskId !== command.taskId)))
             return { outcome: 'failed', error: 'ui_result_target_mismatch' };
         return this.finish(result.commandId, result, fingerprint);
     }
@@ -114,8 +132,7 @@ export class WorkspaceUiTools {
             .map(([commandId, pending]) => this.finish(commandId, { commandId, viewId: pending.command.viewId, status: 'failed', reason })));
     }
     async reject(client, requestId, reason) {
-        await client.respond(requestId, { success: false, contentItems: [{ type: 'inputText', text: JSON.stringify({ status: 'failed', reason }) }] })
-            .catch(() => undefined);
+        await rejectTool(client, requestId, reason);
     }
     async finish(commandId, result, fingerprint) {
         const pending = this.pending.get(commandId);

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

@@ -0,0 +1,44 @@
+export const PREVIEW_DIAGNOSTICS_MARKER = 'data-playcraft-diagnostics';
+/**
+ * Runs only inside a published preview. It reports browser-visible failures and a small
+ * performance sample to the workspace; delivery builds never include this script.
+ */
+export const PREVIEW_DIAGNOSTICS_SCRIPT = `(function(){
+ if(window.__playcraftDiagnosticsV1)return;
+ window.__playcraftDiagnosticsV1=true;
+ var pageId=Math.random().toString(36).slice(2)+Date.now().toString(36);
+ var seq=0,buffer=[],seen={},stopped=false,start=Date.now();
+ function clean(value){try{return String(value).slice(0,2000)}catch(e){return ''}}
+ function emit(type,data){if(stopped||buffer.length>=100)return;var key=type+':'+(data.message||data.url||'');if(seen[key])return;seen[key]=1;buffer.push(Object.assign({type:type,at:Date.now()-start},data));}
+ function flush(){if(!buffer.length)return;var batch=buffer.splice(0,10);seq++;try{window.parent.postMessage({__playcraft:'diagnostics',v:1,pageId:pageId,seq:seq,events:batch},'*')}catch(e){}}
+ var timer=setInterval(flush,500);
+ window.addEventListener('error',function(event){
+   var target=event.target;
+   if(target&&target!==window&&target.tagName){emit('resource',{tag:String(target.tagName).toLowerCase(),url:clean(target.currentSrc||target.src||target.href||'')});return;}
+   emit('error',{message:clean(event.message),source:clean(event.filename),line:event.lineno,col:event.colno});
+ },true);
+ window.addEventListener('unhandledrejection',function(event){var reason=event.reason;emit('unhandledrejection',{message:clean(reason&&reason.message?reason.message:reason)});});
+ window.addEventListener('securitypolicyviolation',function(event){emit('securitypolicyviolation',{message:clean(event.violatedDirective),source:clean(event.blockedURI)});});
+ window.addEventListener('webglcontextlost',function(){emit('webgl-context-lost',{message:'webgl context lost'});},true);
+ function navigation(){
+   try{var entry=performance.getEntriesByType('navigation')[0];if(entry)emit('navigation',{duration:Math.round(entry.duration),domContentLoaded:Math.round(entry.domContentLoadedEventEnd),load:Math.round(entry.loadEventEnd)});}catch(e){}
+   try{var paint=performance.getEntriesByType('paint');for(var i=0;i<paint.length;i++){if(paint[i].name==='first-contentful-paint')emit('paint',{message:'first-contentful-paint',duration:Math.round(paint[i].startTime)});}}catch(e){}
+ }
+ if(document.readyState==='complete')navigation();else window.addEventListener('load',navigation,{once:true});
+ try{var observer=new PerformanceObserver(function(list){var entries=list.getEntries();for(var i=0;i<entries.length;i++){if(entries[i].name==='first-contentful-paint')emit('paint',{message:'first-contentful-paint',duration:Math.round(entries[i].startTime)});}});observer.observe({type:'paint',buffered:true});}catch(e){}
+ var frames=0,fpsStart=performance.now();
+ function sample(){frames++;var now=performance.now();if(now-fpsStart<5000){requestAnimationFrame(sample);}else{emit('fps',{fps:Math.round(frames/((now-fpsStart)/1000))});}}
+ requestAnimationFrame(sample);
+ window.setTimeout(function(){flush();stopped=true;clearInterval(timer);},60000);
+})();`;
+/** Injects only at preview publish time, after the builder has produced a single HTML file. */
+export function injectPreviewDiagnostics(bytes) {
+    const html = bytes.toString('utf8');
+    if (html.includes(PREVIEW_DIAGNOSTICS_MARKER))
+        return bytes;
+    const script = `<script ${PREVIEW_DIAGNOSTICS_MARKER}>${PREVIEW_DIAGNOSTICS_SCRIPT}</script>`;
+    const head = /<head[^>]*>/i.exec(html);
+    const body = /<\/body\s*>/i.exec(html);
+    const at = head ? head.index + head[0].length : body ? body.index : html.length;
+    return Buffer.from(html.slice(0, at) + script + html.slice(at), 'utf8');
+}

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

@@ -10,6 +10,9 @@ import { runDeveloperCommand } from '../workspaces/developer-command.js';
 import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
 import { classifyPreviewOutput, findExternalLocalReferences } from './single-file.js';
 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';
@@ -68,19 +71,31 @@ export async function runPreviewPublish(state, operation, root) {
         : { sessionId: operation.sessionId, clientRequestId: operation.clientRequestId };
     const outputDir = join(root, OUTPUT_FOLDER, operation.operationId);
     const output = { log: '' };
+    const operationLog = new OperationLogStore(state.config.stateDir);
+    let logChain = Promise.resolve();
+    const appendLog = (text) => {
+        logChain = logChain.then(() => operationLog.append(operation.operationId, text)).catch(() => undefined);
+    };
+    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);
-        const bytes = 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);
@@ -124,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')
@@ -132,7 +149,8 @@ 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', {
                 workspaceId,
@@ -146,6 +164,7 @@ export async function runPreviewPublish(state, operation, root) {
         throw new PreviewFailure(code);
     }
     finally {
+        await logChain;
         await rm(outputDir, { recursive: true, force: true }).catch(() => undefined);
     }
 }
@@ -170,16 +189,18 @@ async function ensureDependencies(state, workspaceId, root, output) {
         throw new PreviewFailure('dependencies_not_ready');
     }
 }
-async function buildPreview(state, root, outputDir, operationId, output) {
+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) => {
-            output.log = (output.log + String(chunk)).slice(-64 * 1024);
+            const text = String(chunk);
+            output.log = (output.log + text).slice(-64 * 1024);
+            onLog?.(text);
         },
     });
     if (outcome.code !== 0)