@playcraft/cli 0.1.64 → 0.1.65

package/dist/model-adaptation/project.js

@@ -39,7 +39,7 @@ export async function generateModelAdaptationProject(input) {
         'src/runtime/model-adaptation-core.js': core, 'src/runtime/model-adaptation-core.js.map': coreMap, 'src/assets/packed-model.glb': source.packed,
         '.playcraft/workspace.json': json({ parameters: { schemaPath: 'src/theme/theme.schema.json', dataPath: '.playcraft/model-adaptation.json', themeId: 'default' } }),
         '.playcraft/model-adaptation.json': json(plan), '.playcraft/parent-model-adaptation.json': parentRaw,
-        '.playcraft/model-adaptation-lineage.json': json({ schemaVersion: 1, fixtureOnly: input.fixtureOnly === true, parentSource: parentPlan.source,
+        '.playcraft/model-adaptation-lineage.json': json({ schemaVersion: 1, buildBindingVersion: 2, fixtureOnly: input.fixtureOnly === true, parentSource: parentPlan.source,
             parentPlanHash: modelSourceDigest(parentRaw), derivedSource, derivedPlanHash: modelSourceDigest(json(plan)), coreHash, packedHash: source.packedHash,
             candidateId, loaderVersion: '0.183.2', loaderRevision: '183', geometryValidation: 'pending-runtime', modelInference: false, modelAcceptance: false }),
         'src/theme/theme.schema.json': json({ type: 'object', additionalProperties: false, properties: {
@@ -48,7 +48,7 @@ export async function generateModelAdaptationProject(input) {
                 transform: { type: 'object', properties: { scale: { type: 'number', minimum: .000001, maximum: 1000000, title: 'Model scale' }, position: { type: 'array', readOnly: true }, rotationDegrees: { type: 'array', readOnly: true } } },
                 materialOverrides: { type: 'array', readOnly: true }, visibility: { type: 'array', readOnly: true }, hinges: { type: 'array', readOnly: true },
             } }),
-        'AGENTS.md': '# Adapted model project\n\nSource files and the parent adaptation bytes are immutable copies. Save derived configuration through normal workspace operations. Final deliveries belong in root dist/, including dist/playable/index.html; all delivery dependencies must be packaged there. Private inputs and failed evidence stay outside dist/. A static model has no inferred opening capability.\n',
+        'AGENTS.md': '# Adapted model project\n\nSource files and the parent adaptation bytes are immutable copies. Save derived configuration through normal workspace operations. Final deliveries belong in root dist/, including dist/preview/index.html; all delivery dependencies must be packaged there. Private inputs and failed evidence stay outside dist/. A static model has no inferred opening capability.\n',
         'README.md': '# Saved-model adaptation project\n\nThis prepares source without installation, building, inference or acceptance. Install pinned dependencies and build normally. The workspace parameter panel edits scalar production values; structural mappings and arrays belong to the adaptation panel. Both save .playcraft/model-adaptation.json. Original source/ files and exact parent plan are retained. Runtime geometry identities are checked by the same core as the model viewer. Skin, animation, morph targets and instancing are unsupported; merged parts need a real split. Preview controls are temporary.\n',
     };
     const adaptationPaths = Object.keys(files).filter(path => path.startsWith('src/') || path.startsWith('scripts/') ||

package/dist/model-preparation/pipeline-engine.js

@@ -0,0 +1,157 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { modelPreparationPayloadSchema, workspaceModelAdaptationSchema, canonicalModelAdaptation } from '@playcraft/common/cloud-workspace/runtime';
+import { inspectModelSourceFiles } from '../model-adaptation/source.js';
+import { generateModelAdaptationProject } from '../model-adaptation/project.js';
+import { inspectRigidModel } from '../model-adaptation/node-inspection.js';
+import { applyRigidVertexRepairs } from './vertex-repairs.js';
+import { prepareRigidSplit } from './split-rigid.js';
+import { optimizeModel } from '../model-optimization/optimize.js';
+import { hash, hashData, preparationInventory, readPreparationFile, readPreparationJson, writePreparationJson } from './pipeline-files.js';
+/** Deterministic stages only. All destinations are fresh; prior incomplete attempts remain available. */
+export async function runPreparationEngine(input) {
+    const payload = modelPreparationPayloadSchema.parse(input.payload), { resumeFromReceiptHash: _resume, ...request } = payload;
+    const inputHash = hashData(request);
+    await mkdir(input.outputRoot, { recursive: true });
+    const checkpoint = await readPreparationJson(input.outputRoot, 'checkpoint.json') ?? {
+        schemaVersion: 1, inputHash, toolHash: input.toolHash, stages: {},
+    };
+    if (checkpoint.schemaVersion !== 1 || checkpoint.inputHash !== inputHash || checkpoint.toolHash !== input.toolHash)
+        throw Error('model_prepare_checkpoint_identity_changed');
+    const stage = async (name, identity, action) => {
+        input.signal?.throwIfAborted();
+        const stageHash = hashData({ inputHash, toolHash: input.toolHash, identity });
+        const prior = checkpoint.stages[name];
+        if (prior) {
+            if (prior.inputHash !== stageHash || !new RegExp(`^${name}-[a-f0-9-]{36}$`).test(prior.directory))
+                throw Error('model_prepare_checkpoint_identity_changed');
+            const actual = await preparationInventory(join(input.outputRoot, prior.directory));
+            if (canonicalModelAdaptation(actual) !== canonicalModelAdaptation(prior.files))
+                throw Error('model_prepare_checkpoint_output_changed');
+            return join(input.outputRoot, prior.directory);
+        }
+        const relative = `${name}-${randomUUID()}`, directory = join(input.outputRoot, relative);
+        await mkdir(directory);
+        await action(directory);
+        input.signal?.throwIfAborted();
+        const files = await preparationInventory(directory);
+        checkpoint.stages[name] = { inputHash: stageHash, directory: relative, files };
+        await writePreparationJson(join(input.outputRoot, 'checkpoint.json'), checkpoint, true);
+        return directory;
+    };
+    const observed = await inspectModelSourceFiles({ projectRoot: input.sourceRoot, modelPath: payload.source.path, signal: input.signal });
+    if (canonicalModelAdaptation({ ...observed.source, files: [...observed.source.files].sort((a, b) => a.path.localeCompare(b.path)) }) !==
+        canonicalModelAdaptation({ ...payload.source, files: [...payload.source.files].sort((a, b) => a.path.localeCompare(b.path)) }))
+        throw Error('model_prepare_source_identity_mismatch');
+    if (observed.metadata.unsupported.length)
+        throw Error('model_prepare_rigid_source_required');
+    if (payload.recipe.adaptation && canonicalModelAdaptation(payload.recipe.adaptation.source) !== canonicalModelAdaptation(payload.source))
+        throw Error('model_prepare_adaptation_source_mismatch');
+    if (payload.recipe.repair && (!/\.glb$/i.test(payload.source.path) || payload.source.files.length !== 1))
+        throw Error('model_prepare_repair_glb_required');
+    const initial = await stage('inspect', payload.source, async (directory) => {
+        await writeFile(join(directory, 'model.glb'), observed.packed, { flag: 'wx' });
+        await writeFile(join(directory, 'source-inspection.json'), JSON.stringify({ source: observed.source, packedHash: observed.packedHash, metadata: observed.metadata }) + '\n', { flag: 'wx' });
+    });
+    let current = join(initial, 'model.glb');
+    const lineage = [{ name: 'inspect', directory: initial }];
+    if (payload.recipe.repair) {
+        const bytes = new Uint8Array(await readFile(current)), recipe = { ...payload.recipe.repair, weldedPositionIdentity: 'exact-local-float32-lexicographic-v1' };
+        const repaired = await stage('repair', { parentHash: hash(bytes), recipe }, async (directory) => {
+            const result = applyRigidVertexRepairs(bytes, recipe);
+            await writeFile(join(directory, 'model.glb'), result.bytes, { flag: 'wx' });
+            await writeFile(join(directory, 'repair-manifest.json'), JSON.stringify(result.manifest) + '\n', { flag: 'wx' });
+        });
+        current = join(repaired, 'model.glb');
+        lineage.push({ name: 'repair', directory: repaired });
+    }
+    let splitManifest;
+    if (payload.recipe.split) {
+        const bytes = new Uint8Array(await readFile(current));
+        const split = await stage('split', { parentHash: hash(bytes), recipe: payload.recipe.split }, async (directory) => {
+            const result = prepareRigidSplit(bytes, payload.recipe.split, input.signal);
+            await writeFile(join(directory, 'model.glb'), result.bytes, { flag: 'wx' });
+            await writeFile(join(directory, 'split-manifest.json'), JSON.stringify(result.manifest) + '\n', { flag: 'wx' });
+            await writeFile(join(directory, 'exterior-trace.json'), JSON.stringify(result.trace) + '\n', { flag: 'wx' });
+        });
+        current = join(split, 'model.glb');
+        splitManifest = JSON.parse(await readFile(join(split, 'split-manifest.json'), 'utf8'));
+        lineage.push({ name: 'split', directory: split });
+    }
+    // Verify exact runtime fingerprints across texture-only optimization, including grouped meshes.
+    const beforeBytes = new Uint8Array(await readFile(current));
+    const beforeSource = { kind: 'resource', path: 'prepared/model.glb', contentHash: hash(beforeBytes), files: [{ path: 'prepared/model.glb', contentHash: hash(beforeBytes) }] };
+    const before = await inspectRigidModel({ bytes: beforeBytes, source: beforeSource,
+        adaptation: payload.recipe.adaptation, split: splitManifest, requiredCapability: payload.requiredCapability, signal: input.signal });
+    if (payload.recipe.optimize) {
+        const optimized = await stage('optimize', { parentHash: hash(beforeBytes), recipe: payload.recipe.optimize }, async (directory) => {
+            await optimizeModel({ input: current, output: join(directory, 'model.glb'), lineagePath: join(directory, 'optimization.json'),
+                ...payload.recipe.optimize, texturesOnly: true, maxOutputBytes: payload.maxModelBytes });
+        });
+        current = join(optimized, 'model.glb');
+        lineage.push({ name: 'optimize', directory: optimized });
+    }
+    const finalBytes = new Uint8Array(await readFile(current));
+    if (finalBytes.length > payload.maxModelBytes)
+        throw Error('model_prepare_model_budget_exceeded');
+    const derived = Boolean(payload.recipe.repair || payload.recipe.split || payload.recipe.optimize);
+    const source = derived ? { ...beforeSource, contentHash: hash(finalBytes), files: [{ path: beforeSource.path, contentHash: hash(finalBytes) }] } : payload.source;
+    const inspection = await inspectRigidModel({ bytes: finalBytes, source, adaptation: payload.recipe.adaptation, split: splitManifest,
+        requiredCapability: payload.requiredCapability, signal: input.signal });
+    if (inspection.triangles > payload.maxTriangles)
+        throw Error('model_prepare_triangle_budget_exceeded');
+    const geometry = (value) => value.inventory.nodes.map(({ sourceNodeId, geometryHash }) => ({ sourceNodeId, geometryHash }));
+    if (canonicalModelAdaptation(geometry(before)) !== canonicalModelAdaptation(geometry(inspection)))
+        throw Error('model_prepare_optimized_geometry_changed');
+    const adapted = await stage('adapt', { source, plan: inspection.plan }, async (directory) => {
+        const inputRoot = join(directory, 'input');
+        await mkdir(inputRoot);
+        if (derived) {
+            await mkdir(join(inputRoot, 'prepared'));
+            await writeFile(join(inputRoot, source.path), finalBytes, { flag: 'wx' });
+        }
+        else
+            for (const [path, bytes] of observed.originalFiles) {
+                await mkdir(dirname(join(inputRoot, path)), { recursive: true });
+                await writeFile(join(inputRoot, path), bytes, { flag: 'wx' });
+            }
+        await mkdir(join(inputRoot, '.playcraft'));
+        await writeFile(join(inputRoot, '.playcraft/model-adaptation.json'), JSON.stringify(inspection.plan, null, 2) + '\n', { flag: 'wx' });
+        const generated = await generateModelAdaptationProject({ projectRoot: inputRoot, planPath: '.playcraft/model-adaptation.json',
+            outputRoot: join(directory, 'project'), candidateId: payload.pipelineId, signal: input.signal });
+        const project = generated.outputRoot, proofPrefix = `.playcraft/model-production/${payload.pipelineId}`, proofRoot = join(project, proofPrefix);
+        await mkdir(proofRoot, { recursive: true });
+        const proof = { schemaVersion: 1, pipelineId: payload.pipelineId, stepId: payload.stepId, inputHash,
+            sourceScope: payload.sourceScope, parentSource: payload.source, recipe: payload.recipe, toolHash: input.toolHash,
+            outputSource: generated.manifest.derivedSource, actualInspection: inspection, modelAcceptance: false, browserValidation: 'pending' };
+        await writeFile(join(proofRoot, 'lineage.json'), JSON.stringify(proof, null, 2) + '\n', { flag: 'wx' });
+        await writeFile(join(proofRoot, 'recipe.json'), JSON.stringify(payload.recipe, null, 2) + '\n', { flag: 'wx' });
+        await writeFile(join(proofRoot, 'tool.json'), JSON.stringify({ toolHash: input.toolHash, manifest: input.toolManifest, actualInspector: inspection.tool }, null, 2) + '\n', { flag: 'wx' });
+        for (const [path, bytes] of observed.originalFiles) {
+            await mkdir(dirname(join(proofRoot, 'original', path)), { recursive: true });
+            await writeFile(join(proofRoot, 'original', path), bytes, { flag: 'wx' });
+        }
+        for (const item of lineage)
+            for (const file of await preparationInventory(item.directory)) {
+                await writeFile(join(proofRoot, `${item.name}-${file.path.replaceAll('/', '-')}`), (await readPreparationFile(item.directory, file.path)).bytes, { flag: 'wx' });
+            }
+        const buildPath = join(project, '.playcraft/model-build-inputs.json'), build = JSON.parse(await readFile(buildPath, 'utf8'));
+        for (const file of await preparationInventory(proofRoot))
+            build.models[0].adaptationFiles.push({ path: `${proofPrefix}/${file.path}`, contentHash: file.contentHash });
+        if (build.models[0].adaptationFiles.length > 64)
+            throw Error('model_prepare_lineage_limit');
+        await writeFile(buildPath, JSON.stringify(build, null, 2) + '\n');
+        const sourceManifestPath = join(project, 'model-adaptation-source-manifest.json');
+        const sourceManifest = JSON.parse(await readFile(sourceManifestPath, 'utf8'));
+        sourceManifest.files = (await preparationInventory(project)).filter(file => !['AGENTS.md', 'README.md', 'model-adaptation-source-manifest.json'].includes(file.path));
+        sourceManifest.preservedWorkspaceInstructions = true;
+        await writeFile(sourceManifestPath, JSON.stringify(sourceManifest, null, 2) + '\n');
+    });
+    const projectRoot = join(adapted, 'project'), config = await readPreparationFile(projectRoot, '.playcraft/model-adaptation.json');
+    const plan = workspaceModelAdaptationSchema.parse(JSON.parse(config.bytes.toString('utf8')));
+    const files = await preparationInventory(projectRoot);
+    return { status: 'prepared', projectRoot, model: plan.source, adaptationPath: '.playcraft/model-adaptation.json', adaptationHash: config.contentHash,
+        modelBytes: finalBytes.length, triangles: inspection.triangles, files,
+        lineageFiles: files.filter(file => file.path.startsWith(`.playcraft/model-production/${payload.pipelineId}/`)).map(({ path, contentHash }) => ({ path, contentHash })) };
+}

package/dist/model-preparation/pipeline-files.js

@@ -0,0 +1,108 @@
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, realpath, rename, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { workspaceRelativePathSchema, canonicalModelAdaptation } from '@playcraft/common/cloud-workspace/runtime';
+import { modelSourceDigest as hash } from '../model-adaptation/source.js';
+export const hashData = (value) => hash(canonicalModelAdaptation(value));
+export function preparationPath(value) {
+    workspaceRelativePathSchema.parse(value);
+    if (value.split('/').some(part => ['.git', '.ssh', 'node_modules'].includes(part) || part === '.env' || part.startsWith('.env.')))
+        throw Error('model_prepare_path_unsafe');
+    return value;
+}
+const same = (a, b) => a.ino === b.ino && a.dev === b.dev && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+/** Safe byte reads include inode/parent identity checks before and after reading, not only a digest. */
+export async function readPreparationFile(root, relative, maximum = 64 * 1024 * 1024) {
+    preparationPath(relative);
+    const base = resolve(root);
+    if (await realpath(base) !== base || !(await lstat(base)).isDirectory())
+        throw Error('model_prepare_root_unsafe');
+    const parents = [];
+    let path = base;
+    for (const part of relative.split('/').slice(0, -1)) {
+        path = join(path, part);
+        const stat = await lstat(path);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw Error('model_prepare_path_unsafe');
+        parents.push({ path, stat });
+    }
+    path = join(base, relative);
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size > maximum)
+            throw Error('model_prepare_file_bound');
+        const bytes = await handle.readFile();
+        if (!same(stat, await handle.stat()) || !same(stat, await lstat(path)) || await realpath(path) !== path)
+            throw Error('model_prepare_source_changed');
+        for (const parent of parents) {
+            const now = await lstat(parent.path);
+            if (!now.isDirectory() || now.isSymbolicLink() || now.ino !== parent.stat.ino || now.dev !== parent.stat.dev)
+                throw Error('model_prepare_source_changed');
+        }
+        return { bytes, stat, contentHash: hash(bytes) };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function writePreparationJson(path, value, shared = false) {
+    await mkdir(dirname(path), { recursive: true, mode: shared ? 0o2770 : 0o700 });
+    const temporary = `${path}.${randomUUID()}.pending`;
+    try {
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, shared ? 0o660 : 0o600);
+        try {
+            await handle.writeFile(JSON.stringify(value, null, 2) + '\n');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, path);
+        const directory = await open(dirname(path), constants.O_RDONLY);
+        try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function preparationInventory(root) {
+    const files = [];
+    let total = 0;
+    async function walk(prefix = '') {
+        for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
+            const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+            preparationPath(path);
+            if (entry.isSymbolicLink())
+                throw Error('model_prepare_path_unsafe');
+            if (entry.isDirectory())
+                await walk(path);
+            else {
+                const file = await readPreparationFile(root, path);
+                total += file.bytes.length;
+                if (files.length >= 256 || total > 256 * 1024 * 1024)
+                    throw Error('model_prepare_inventory_bound');
+                files.push({ path, contentHash: file.contentHash, bytes: file.bytes.length });
+            }
+        }
+    }
+    await walk();
+    return files.sort((a, b) => a.path.localeCompare(b.path, 'en'));
+}
+export async function readPreparationJson(root, path, maximum = 4 * 1024 * 1024) {
+    try {
+        return JSON.parse((await readPreparationFile(root, path, maximum)).bytes.toString('utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+export { hash };

package/dist/model-preparation/pipeline-worker.js

@@ -0,0 +1,32 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { modelPreparationPayloadSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { runPreparationEngine } from './pipeline-engine.js';
+import { hash, writePreparationJson } from './pipeline-files.js';
+/** Internal frozen CLI worker; accepts neither a project module nor executable recipe strings. */
+export async function modelPrepareWorker(configPath, expectedHash) {
+    const bytes = await readFile(configPath);
+    if (hash(bytes) !== expectedHash)
+        throw Error('model_prepare_worker_input_changed');
+    const config = JSON.parse(bytes.toString('utf8'));
+    const payload = modelPreparationPayloadSchema.parse(config.payload);
+    try {
+        const result = await runPreparationEngine({ payload, sourceRoot: config.sourceRoot, outputRoot: config.outputRoot, toolHash: config.toolHash, toolManifest: config.tools });
+        await writePreparationJson(join(config.outputRoot, 'result.json'), result, true);
+    }
+    catch (error) {
+        const safeCode = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
+            && /^model_adaptation_[a-z_]+$/.test(error.code) ? error.code : undefined;
+        const message = safeCode ?? (error instanceof Error ? error.message : '');
+        let code = message.split(':')[0];
+        if (['invalid_model', 'invalid_model_resource', 'invalid_model_image', 'asset_too_large'].includes(code))
+            code = `model_prepare_${code}`;
+        if (!/^(model_prepare_|model_preparation_|model_adaptation_|model_source_|optimization_)[a-z_]+$/.test(code))
+            throw error;
+        await writePreparationJson(join(config.outputRoot, 'result.json'), { status: 'blocked', reasonCode: code }, true);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    modelPrepareWorker(process.argv[2] ?? '', process.argv[3] ?? '').catch(() => { process.stderr.write('model_prepare_worker_failed\n'); process.exitCode = 1; });
+}

package/dist/workspace-runtime/batch/deliver.js

@@ -9,10 +9,10 @@ import { workspaceRoot } from '../workspaces/registry.js';
 import { processHasExited, runProcessGroup, stopProcessGroup } from './processes.js';
 import { stopMemberWriters } from './writer-proof.js';
 import { memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
-/** Base build writes dist/index.html. Channel packaging stays on export playable (`--mode full`). */
+/** Base build writes dist/index.html. Channel packaging is done by platform export. */
 function buildCommand() {
     return (process.env.PLAYCRAFT_BATCH_BUILD_COMMAND
-        ?? 'umask 002 && CI=1 playcraft build --mode base --output dist .');
+        ?? 'umask 002 && CI=1 playcraft build --base --output dist .');
 }
 /**
  * The batch build runs as the runtime identity while the agent wrote the tree as the development

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

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
-import { DELIVERY_CHANNELS, } from '@playcraft/common/cloud-workspace/runtime';
+import { DELIVERY_CHANNELS, deliveryExportOptionsSchema, } 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: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit. Each channel uses the same fixed HTML or ZIP choice as the Export button for that channel and the project engine. Other options reuse the channel\'s latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. If the result is pending at workspace.save, finish the current turn without polling so the save can run, then continue the export in a later turn. Once build ids are returned, poll playcraft_get_delivery for status, checks and failure details.',
+        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit. Each channel uses the same fixed HTML or ZIP choice as the Export button for that channel and the project engine. Build options given in `options` apply to every requested channel and replace that setting from the channel\'s latest export on this branch; options not given reuse that export, or the defaults when it has none. Store links not given come from the project\'s remembered export links, then from the channel\'s latest export. A later export without `options` keeps the settings this one used. A workspace without a project first gets one, with a private repository, as its first save would. If the result is pending at workspace.save, finish the current turn without polling so the save can run, then continue the export in a later turn. Once build ids are returned, poll playcraft_get_delivery for status, checks and failure details.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -16,6 +16,32 @@ export const WORKSPACE_DELIVERY_TOOLS = [
                     maxItems: DELIVERY_CHANNELS.length,
                     uniqueItems: true,
                 },
+                options: {
+                    type: 'object',
+                    description: 'Optional. Set only the options to change; each one left out keeps its current setting. Each option affects the size and quality of the channel packages.',
+                    properties: {
+                        compressImages: { type: 'boolean', description: 'Lossy palette compression (pngquant) of PNG images.' },
+                        imageQuality: { type: 'integer', minimum: 40, maximum: 95, description: 'Quality of lossy image compression, 40 to 95; lower is smaller and blurrier. Used with compressImages.' },
+                        convertToWebP: { type: 'boolean', description: 'Convert PNG and JPG images to WebP, usually much smaller; on by default.' },
+                        compressModels: { type: 'boolean', description: 'Compress 3D model geometry.' },
+                        modelCompression: { type: 'string', enum: ['draco', 'meshopt'], description: 'Model compression method: draco is widely supported, meshopt compresses further. Used with compressModels.' },
+                        jsMinify: { type: 'boolean', description: 'Minify and obfuscate JavaScript; on by default.' },
+                        cssMinify: { type: 'boolean', description: 'Minify CSS; on by default.' },
+                        selectedScenes: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 100, uniqueItems: true, description: 'Package just these scene names; scenes left out are not in the package.' },
+                        esmMode: { type: 'string', enum: ['auto', 'enabled', 'disabled'], description: 'How ES modules are bundled; auto detects them.' },
+                        storeUrls: {
+                            type: 'object',
+                            description: 'App store links the call-to-action opens. A link given is used for that store; a store not given keeps the project\'s remembered link, or the channel\'s latest export link.',
+                            properties: {
+                                ios: { type: 'string', format: 'uri', description: 'iOS App Store URL (http or https).' },
+                                android: { type: 'string', format: 'uri', description: 'Google Play URL (http or https).' },
+                            },
+                            minProperties: 1,
+                            additionalProperties: false,
+                        },
+                    },
+                    additionalProperties: false,
+                },
             },
             additionalProperties: false,
         },
@@ -70,7 +96,7 @@ export class WorkspaceDeliveryTools {
             await this.reject(client, requestId, 'permission_denied');
             return;
         }
-        const unknown = Object.keys(input).filter(key => key !== 'channels');
+        const unknown = Object.keys(input).filter(key => key !== 'channels' && key !== 'options');
         if (unknown.length) {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
@@ -82,6 +108,12 @@ export class WorkspaceDeliveryTools {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
         }
+        const options = input.options === undefined ? { success: true, data: undefined }
+            : deliveryExportOptionsSchema.safeParse(input.options);
+        if (!options.success || (options.data?.selectedScenes && new Set(options.data.selectedScenes).size !== options.data.selectedScenes.length)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
         try {
             const result = await this.handlers.build({
                 ...context,
@@ -89,6 +121,7 @@ export class WorkspaceDeliveryTools {
                     ? payload.callId
                     : randomUUID(),
                 channels: channels,
+                ...(options.data ? { options: options.data } : {}),
             });
             await this.respond(client, requestId, result);
         }

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

@@ -12,7 +12,7 @@ import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
 import { classifyPreviewOutput, findExternalLocalReferences } from './single-file.js';
 import { finalizeWorkspacePlayable, readWorkspacePlayable, workspacePlayableSignature } from './finalize.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
-import { isolateWorkspaceForBuild } from '../workspaces/delivery-build.js';
+import { isolateWorkspaceForBuild } from '../workspaces/build-isolation.js';
 import { openScratchToDevelopment } from '../workspaces/directory-access.js';
 import { injectPreviewDiagnostics } from './diagnostics.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
@@ -27,7 +27,7 @@ const BUILDER_TEMP_FOLDER = '.playcraft-temp';
  * The generic single-file build. `--mode full` keeps the builder from asking which stages to run.
  * Group-writable output lets the control user, a member of the development group, remove it.
  */
-const BUILD_COMMAND = 'umask 002 && PLAYCRAFT_BUILD_ISOLATED=1 playcraft build --mode full --platform playcraft --format html';
+const BUILD_COMMAND = 'umask 002 && PLAYCRAFT_BUILD_ISOLATED=1 playcraft build';
 class PreviewFailure extends Error {
     code;
     constructor(code) {

package/dist/workspace-runtime/serve.js

@@ -36,6 +36,7 @@ import { platformExportTarget, readPlatformExport, startPlatformExport } from '.
 import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
 import { proceduralSkillHandler } from './workspaces/procedural-3d/host.js';
 import { recoverModelPreviewOperations } from './workspaces/procedural-3d/model-preview-recovery.js';
+import { recoverModelPreparationOperations, stopModelPreparations } from './workspaces/model-preparation.js';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -84,6 +85,9 @@ export async function startWorkspaceRuntime(config, options = {}) {
             runtimeEpoch: config.runtimeEpoch, previousRuntimeEpoch: previousEpoch,
             ...(config.workspaceMode === 'multi' && process.env.PLAYCRAFT_LAUNCHER_SOCKET
                 ? { launcherSocket: process.env.PLAYCRAFT_LAUNCHER_SOCKET } : {}) });
+        await recoverModelPreparationOperations(state, { identityMatches: previousIdentityMatches,
+            runtimeEpoch: config.runtimeEpoch, previousRuntimeEpoch: previousEpoch,
+            ...(config.workspaceMode === 'multi' && process.env.PLAYCRAFT_LAUNCHER_SOCKET ? { launcherSocket: process.env.PLAYCRAFT_LAUNCHER_SOCKET } : {}) });
         const recoveredChanges = [];
         const recoveredWrites = [];
         const recoverLibraryImports = async (root) => {
@@ -316,6 +320,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             async close() {
                 const serverClosed = closeServer(server);
                 await stopParameterVerifications(state);
+                await stopModelPreparations(state);
                 await closeCliCredentials(state);
                 await gitCredentials?.close();
                 try {

package/dist/workspace-runtime/server/directory-access.js

@@ -8,7 +8,7 @@ const instances = new WeakMap();
 const executing = new WeakMap();
 const freezing = new WeakMap();
 const TERMINAL = new Set(['completed', 'failed', 'interrupted']);
-const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'delivery.build', 'model.preview', 'directory.create',
+const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'model.preview', 'model.prepare', 'directory.create',
     'directory.rename', 'directory.delete', 'workspace.references.import', 'skills.update', 'parameter.verify',
     'checkpoint.create', 'checkpoint.restore']);
 export function managedDirectoryScope(state, value) {

package/dist/workspace-runtime/server/dispatch.js

@@ -6,7 +6,7 @@ import { shareWorkspaceGit } from '../workspaces/shared-git.js';
 import { cancelPendingDirectoryAccess, holdDirectoryAccess, withOperationDirectoryAccess } from './directory-access.js';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials, ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
@@ -42,8 +42,8 @@ import { DirectoryMutationError, mutateWorkspaceDirectory } from '../workspaces/
 import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
 import { publishAssetTransfer } from '../workspaces/asset-transfer-publish.js';
 import { AssetTransferError } from '../workspaces/asset-transfer-storage.js';
-import { runDeliveryBuild, cancelDeliveryBuild, trackDeliveryBuild, DeliveryBuildError } from '../workspaces/delivery-build.js';
 import { runModelPreviewBuild, cancelModelPreview, modelPreviewError } from '../workspaces/procedural-3d/model-preview-build.js';
+import { runModelPreparation, trackModelPreparation } from '../workspaces/model-preparation.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -76,10 +76,9 @@ const LOCAL_KINDS = new Set([
     'parameter.patch',
     'parameter.verify',
     'preview.publish',
-    'delivery.build',
-    'delivery.cancel',
     'model.preview',
     'model.preview.cancel',
+    'model.prepare',
     'skills.update',
 ]);
 const parameterVerifications = new WeakMap();
@@ -123,7 +122,7 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
             return executeScopedOperation(state, scopeKey, operation, payload, recovery);
         }, { operationId: operation.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}) });
     };
-    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel', 'model.preview', 'model.preview.cancel'].includes(operation.kind)) {
+    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'model.preview', 'model.preview.cancel', 'model.prepare'].includes(operation.kind)) {
         return run();
     }
     return state.journal.exclusive(operation.kind.startsWith('session.') && operation.sessionId
@@ -199,15 +198,32 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'preview.publish') {
         return executePreviewPublish(state, scopeKey, current);
     }
-    if (operation.kind === 'delivery.build') {
-        return executeDeliveryBuild(state, scopeKey, current, payload);
-    }
-    if (operation.kind === 'delivery.cancel') {
-        return executeDeliveryCancel(state, scopeKey, current, payload);
-    }
     if (operation.kind === 'model.preview' || operation.kind === 'model.preview.cancel') {
         return executeModelPreview(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'model.prepare') {
+        const accepted = await persist(state, scopeKey, transitionOperation(current, 'accepted'));
+        const task = runModelPreparation(state, accepted, payload, { onFile: async (file) => {
+                const scope = revisionScope(state, accepted.workspaceId, accepted.directoryName);
+                const existing = state.journal.listEvents().some(event => {
+                    const payload = asRecord(event.payload);
+                    return event.type === 'file.written' &&
+                        payload.operationId === accepted.operationId && payload.path === file.path && payload.contentHash === file.contentHash;
+                });
+                if (existing)
+                    return;
+                const previous = state.journal.fileRevisions(scope)[file.path];
+                const revision = previous ? previous.revision + (previous.contentHash === file.contentHash ? 0 : 1) : 1;
+                await state.journal.putFileRevision(file.path, { contentHash: file.contentHash, revision }, scope);
+                await recordNativeEvents(state, accepted, [{ type: 'file.written', payload: { ...file, revision, writer: 'manual',
+                            operationId: accepted.operationId, source: 'model.prepare' }, occurredAt: new Date().toISOString() }]);
+            } }).then(async (result) => { await persist(state, scopeKey, transitionOperation(accepted, 'completed', { result })); }, async (error) => {
+            const message = error instanceof Error ? error.message : '', code = /^model_prepare_[a-z_]+$/.test(message) ? message : 'model_prepare_failed';
+            await persist(state, scopeKey, transitionOperation(accepted, code === 'model_prepare_process_unknown' ? 'uncertain' : ['model_prepare_cancelled', 'model_prepare_timeout'].includes(code) ? 'interrupted' : 'failed', { error: code }));
+        });
+        trackModelPreparation(state, task);
+        return accepted;
+    }
     if (!state.native?.ready()) {
         return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
     }
@@ -1533,42 +1549,6 @@ async function executeModelPreview(state, scopeKey, operation, payload) {
     }).catch(() => undefined));
     return accepted;
 }
-async function executeDeliveryBuild(state, scopeKey, operation, payload) {
-    const parsed = deliveryBuildPayloadSchema.safeParse(payload);
-    if (!parsed.success) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_build' }));
-    }
-    if (!operation.workspaceId) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace' }));
-    }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
-    const task = runDeliveryBuild(state, {
-        buildId: operation.operationId,
-        workspaceId: operation.workspaceId,
-        directoryName: operation.directoryName ?? 'basic',
-        payload: parsed.data,
-        actor: parsed.data.actor ?? 'user',
-    }).then(async (result) => {
-        const error = result.record.error
-            ?? (result.record.status === 'succeeded' ? undefined : 'delivery_build_failed');
-        await persist(state, scopeKey, transitionOperation(accepted, result.record.status === 'succeeded' ? 'completed' : error === 'delivery_process_unknown' ? 'uncertain' : 'failed', error ? { error } : {}));
-    }, async (error) => {
-        await persist(state, scopeKey, transitionOperation(accepted, 'failed', {
-            error: error instanceof DeliveryBuildError ? error.code : 'delivery_build_failed',
-        }));
-    }).catch(() => undefined);
-    trackDeliveryBuild(state, task);
-    return accepted;
-}
-async function executeDeliveryCancel(state, scopeKey, operation, payload) {
-    const parsed = deliveryCancelPayloadSchema.safeParse(payload);
-    if (!parsed.success || !operation.workspaceId) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_cancel' }));
-    }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
-    const canceled = await cancelDeliveryBuild(state, operation.workspaceId, operation.directoryName ?? 'basic', parsed.data.buildId);
-    return persist(state, scopeKey, transitionOperation(accepted, canceled ? 'completed' : 'failed', canceled ? {} : { error: 'delivery_build_not_found' }));
-}
 async function executeTerminalCreate(state, scopeKey, operation, payload) {
     const parsed = terminalCreatePayloadSchema.safeParse(payload ?? {});
     if (!parsed.success) {

package/dist/workspace-runtime/server/http.js

@@ -49,6 +49,7 @@ import { readWorktreeSource, registerChatWorktree } from '../workspaces/worktree
 import { withDirectoryWrite } from './directory-access.js';
 import { readProceduralModelCandidates } from '../workspaces/procedural-3d/read-candidates.js';
 import { ModelPreviewStore } from '../workspaces/procedural-3d/model-preview-store.js';
+import { readModelPreparation } from '../workspaces/model-preparation.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const workspaceId = url.searchParams.get('workspaceId');
@@ -567,6 +568,17 @@ async function dispatchRuntimeRequest(state, request, response) {
             writeJson(response, 200, await readProceduralModelCandidates(root, state.config.stateDir));
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/model-preparations') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId'), pipelineId = url.searchParams.get('pipelineId'), stepId = url.searchParams.get('stepId');
+            if (!workspaceId || !pipelineId || !stepId || directoryName === 'root') {
+                writeJson(response, 400, { error: 'model_prepare_scope_invalid' });
+                return;
+            }
+            writeJson(response, 200, await readModelPreparation(state, workspaceId, directoryName, pipelineId, stepId));
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/artifacts') {
             if (writeDestroyed(state, response))
                 return;