@playcraft/cli 0.1.63 → 0.1.64

package/SKILLS_REGISTRY.md

@@ -90,7 +90,7 @@ playcraft skills registry platform push ./playcraft-video-understanding-1.0.1.ta
 playcraft skills registry platform push ./playcraft-replica-validation-1.0.1.tar.gz --changelog '更新复刻验收指引与评估用例' --json
 ```
 
-`platform push <source>` 接受完整目录或已准备的压缩包。目录必须已含原生 `manifest.json`；命令保留其文件内容，不补充托管技能默认字段。已有压缩包原样发送，不重打包。可选的 `--ref`、`--version` 必须与清单一致；可用 `--evaluation-template <templateId>` 指定初始评估模板。原生入口当前仅接受上述两个引用，要求平台类型、单一 `sandbox-agent` surface、对齐的名称与版本、无 imports/relationships；服务端执行完整校验与摘要归一化，并返回最终 `artifactHash`。登记不会自动评估、审核或发布。
+`platform push <source>` 接受完整目录或已准备的压缩包。目录必须已含原生 `manifest.json`；命令保留其文件内容，不补充托管技能默认字段。已有压缩包原样发送，不重打包。可选的 `--ref`、`--version` 必须与清单一致；可用 `--evaluation-template <templateId>` 指定初始评估模板。原生入口按公共内置技能表允许引用，包含上述两项视频指南及显式导入的 `remix/playcraft-procedural-3d`、`remix/playcraft-model-adaptation`；要求平台类型、单一 `sandbox-agent` surface、对齐的名称与版本、无 imports/relationships。服务端执行完整校验与摘要归一化，并返回最终 `artifactHash`。登记不会自动评估、审核或发布。模型适配指南的独立源版本与门禁见[发布说明](../skills/docs/model-adaptation-skill-release.md)。
 
 此入口要求具有平台管理权限的真实账号凭据；命令复用目标环境登录，不发送本地身份模拟请求头。服务端需已部署允许真实管理员个人访问令牌访问原生登记和评估接口的版本。
 

package/dist/commands/3d.js

@@ -1,6 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, statSync, } from 'fs';
 import { basename, dirname, extname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { inspectModelSourceFiles } from '../model-adaptation/source.js';
+import { generateModelAdaptationProject } from '../model-adaptation/project.js';
+import { optimizeModel } from '../model-optimization/optimize.js';
+import { registerModelPreparationCommands } from '../model-preparation/commands.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PRIMITIVES_DIR = join(__dirname, '../../assets/models/primitives');
 const PRIMITIVES_METADATA = join(PRIMITIVES_DIR, 'metadata.json');
@@ -302,46 +306,23 @@ function registerOptimizeCmd(parent) {
         .requiredOption('--input <path>', 'Input GLB file')
         .requiredOption('--output <path>', 'Output optimized GLB file')
         .option('--texture-size <n>', 'Max texture dimension (default: 512)', '512')
+        .option('--texture-format <format>', 'Explicit texture format: png or jpeg (opaque color textures only)')
+        .option('--quality <n>', 'JPEG texture quality, 1–100 (default: 85)', '85')
+        .option('--textures-only', 'Preserve geometry and node structure; do not deduplicate or prune')
+        .option('--max-output-bytes <n>', 'Reject output larger than this explicit byte budget')
+        .option('--lineage <path>', 'New independent optimization receipt (default: <output>.optimization.json)')
         .option('--target-size <s>', 'Target size hint (e.g. 200KB) — informational only')
         .action(async (opts) => {
         try {
-            const { NodeIO, TextureChannel } = await import('@gltf-transform/core');
-            const { dedup, prune } = await import('@gltf-transform/functions');
-            void TextureChannel; // unused but imported for type context
-            if (!existsSync(opts.input)) {
-                console.error(`Error: input file not found: ${opts.input}`);
-                process.exit(1);
-            }
-            const origSize = statSync(opts.input).size;
-            const io = new NodeIO();
-            const doc = await io.read(opts.input);
-            const maxTexSize = parseInt(opts.textureSize, 10);
-            const sharp = (await import('sharp')).default;
-            // Resize textures that exceed maxTexSize using sharp
-            const textures = doc.getRoot().listTextures();
-            for (const tex of textures) {
-                const imgData = tex.getImage();
-                if (!imgData)
-                    continue;
-                const meta = await sharp(Buffer.from(imgData)).metadata();
-                const w = meta.width ?? 0;
-                const h = meta.height ?? 0;
-                if (w > maxTexSize || h > maxTexSize) {
-                    const resized = await sharp(Buffer.from(imgData))
-                        .resize(maxTexSize, maxTexSize, { fit: 'inside', withoutEnlargement: true })
-                        .png()
-                        .toBuffer();
-                    tex.setImage(new Uint8Array(resized)).setMimeType('image/png');
-                }
-            }
-            await doc.transform(dedup(), prune());
-            ensureOutputDir(opts.output);
-            await io.write(opts.output, doc);
-            const outSize = statSync(opts.output).size;
+            const optimized = await optimizeModel({ input: opts.input, output: opts.output, textureSize: Number(opts.textureSize),
+                textureFormat: opts.textureFormat, quality: Number(opts.quality), texturesOnly: opts.texturesOnly,
+                maxOutputBytes: opts.maxOutputBytes === undefined ? undefined : Number(opts.maxOutputBytes), lineagePath: opts.lineage });
+            const origSize = optimized.lineage.before.modelBytes, outSize = optimized.lineage.after.modelBytes;
             const saving = origSize - outSize;
             const savingPct = ((saving / origSize) * 100).toFixed(1);
             console.log(`Optimized: ${opts.output}`);
             console.log(`  ${sizeLabel(origSize)} → ${sizeLabel(outSize)} (saved ${sizeLabel(saving)}, ${savingPct}%)`);
+            console.log(`  Lineage: ${optimized.lineagePath}`);
         }
         catch (e) {
             handleError(e);
@@ -360,4 +341,31 @@ export function register3DCommands(program) {
     registerApplyTextureCmd(threeD);
     registerConvertCmd(threeD);
     registerOptimizeCmd(threeD);
+    registerModelPreparationCommands(threeD);
+    threeD.command('inspect-source <model>').description('Inspect saved-model dependencies without rendering or inference')
+        .option('--project-root <directory>', 'Source project directory', process.cwd()).option('--json', 'Output structured source metadata')
+        .action(async (model, options) => {
+        try {
+            const result = await inspectModelSourceFiles({ projectRoot: options.projectRoot, modelPath: model });
+            console.log(JSON.stringify({ source: result.source, packedHash: result.packedHash, metadata: result.metadata, modelInference: false, acceptance: false }, null, 2));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    threeD.command('adapt-project').description('Prepare a new rigid-model adaptation project without building or publishing')
+        .requiredOption('--config <file>', 'Source-bound adaptation configuration').option('--project-root <directory>', 'Source project directory', process.cwd())
+        .requiredOption('--output <directory>', 'New output directory').option('--candidate-id <id>', 'Explicit source candidate identity')
+        .option('--fixture-only', 'Mark an engineering fixture without granting acceptance')
+        .action(async (options) => {
+        try {
+            const result = await generateModelAdaptationProject({ projectRoot: options.projectRoot, planPath: options.config, outputRoot: options.output,
+                candidateId: options.candidateId, fixtureOnly: options.fixtureOnly });
+            console.log(JSON.stringify({ outputRoot: result.outputRoot, source: result.manifest.source, coreHash: result.manifest.coreHash,
+                packedHash: result.manifest.packedHash, geometryValidation: result.manifest.geometryValidation, modelInference: false, acceptance: false }, null, 2));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
 }

package/dist/model-adaptation/project-template.js

@@ -0,0 +1,162 @@
+export const modelProjectHtml = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title></title></head><body><main><h1 id="model-title"></h1><p id="status" role="status"></p><div id="stage"></div><section id="controls"></section><p id="model-notice"></p></main><script type="module" src="/src/main.js"></script></body></html>\n`;
+export const modelProjectStrings = { en: { title: 'Adapted model', loading: 'Loading model…', ready: 'Ready', open: 'Open ', close: 'Close ',
+        invalidParameter: 'Invalid parameter', staticModel: 'Static model; no opening capability is declared.',
+        notice: 'Temporary preview controls. Save production values in the workspace parameter panel, then rebuild.', parameterLabels: { scale: 'Model scale', unitScale: 'Unit scale' } },
+    zh: { title: '已有模型适配', loading: '正在加载模型…', ready: '已就绪', open: '打开 ', close: '关闭 ', invalidParameter: '参数无效',
+        staticModel: '静态模型，未声明开合能力。', notice: '这里的调整仅用于当前预览；生产默认值请在工作区参数面板保存后重新构建。', parameterLabels: { scale: '模型缩放', unitScale: '单位比例' } } };
+export const modelProjectAdapter = String.raw `import * as THREE from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { createModelAdaptationCore } from './runtime/model-adaptation-core.js';
+const digestBytes = bytes => bytesToHex(sha256(bytes));
+function disposeSource(scene) {
+  const resources = new Set(), images = new Set();
+  scene.traverse(node => { if (node.geometry) resources.add(node.geometry);
+    for (const material of [node.material].flat().filter(Boolean)) { resources.add(material);
+      for (const value of Object.values(material)) if (value?.isTexture) { resources.add(value); if (value.image?.close) images.add(value.image); } }
+  });
+  for (const resource of resources) resource.dispose(); for (const image of images) image.close();
+}
+export function resolvePackedModelBytes(evidence) {
+  const alias = evidence.packedModelField;
+  if (alias !== undefined && (alias !== 'modelBase64' || Object.hasOwn(evidence, 'packedModelBase64') ||
+    evidence.source?.contentHash !== evidence.packedHash || evidence.binding?.sourceHash !== evidence.packedHash)) throw Error('model_packed_alias_invalid');
+  const encoded = alias === undefined ? evidence.packedModelBase64 : evidence.modelBase64;
+  if (typeof encoded !== 'string' || encoded.length % 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)) throw Error('model_packed_encoding_invalid');
+  const bytes = Uint8Array.from(atob(encoded), char => char.charCodeAt(0));
+  if (digestBytes(bytes) !== evidence.packedHash) throw Error('model_packed_bytes_changed');
+  return bytes;
+}
+export async function loadAdaptedModel(evidence, { signal } = {}) {
+  signal?.throwIfAborted(); const plan = JSON.parse(evidence.configRaw);
+  if (evidence.loaderRevision && THREE.REVISION !== evidence.loaderRevision) throw Error('model_loader_version_changed');
+  const bytes = resolvePackedModelBytes(evidence);
+  const gltf = await new GLTFLoader().parseAsync(bytes.buffer, '');
+  let factory, released = false;
+  const release = () => { if (released) return; released = true; factory?.release(); disposeSource(gltf.scene); };
+  try {
+    signal?.throwIfAborted();
+    factory = await createModelAdaptationCore({ THREE, source: gltf.scene, sourceIdentity: evidence.source,
+      plan, digestBytes, animationCount: gltf.animations.length, signal });
+    signal?.throwIfAborted();
+    return Object.freeze({ factory, plan, THREE, release });
+  } catch (error) { release(); throw error; }
+}
+`;
+export const modelProjectMain = String.raw `import { loadAdaptedModel } from './adapter.js';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import strings from './strings.json';
+import './style.css';
+const evidence = JSON.parse(document.getElementById('playcraft-source-evidence').textContent);
+const stage = document.getElementById('stage'), status = document.getElementById('status'), controlsArea = document.getElementById('controls');
+const locale = navigator.language.startsWith('zh') ? 'zh' : 'en', text = strings[locale]; document.documentElement.lang = locale;
+document.title = text.title; document.getElementById('model-title').textContent = text.title; document.getElementById('model-notice').textContent = text.notice; status.textContent = text.loading;
+const abort = new AbortController(); let stopped = false, loaded, renderer, orbit, instance, observer, renderFailed = false;
+let resolveReady, rejectReady; const ready = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; }); ready.catch(() => {});
+const release = () => { if (stopped) return; stopped = true; abort.abort(); observer?.disconnect(); orbit?.dispose(); loaded?.release(); renderer?.dispose(); };
+const fail = error => { renderFailed = true; rejectReady(error); status.textContent = String(error.message); console.error('model_render_failed', error); parent.postMessage({ type: 'playcraft:game-error' }, '*'); release(); };
+addEventListener('pagehide', release, { once: true });
+try {
+  loaded = await loadAdaptedModel(evidence, { signal: abort.signal });
+  if (stopped) { loaded.release(); throw Error('model_closed'); }
+  const { THREE, factory, plan } = loaded, opened = new Set(), probes = new WeakMap();
+  const defaults = { scale: plan.transform.scale, unitScale: plan.normalization.unitScale };
+  for (const hinge of plan.hinges) defaults['hinge:' + hinge.id] = hinge.openAngleDegrees;
+  const materialKey = (field, value) => field + ':' + value.nodeRef.sourceNodeId + ':' + value.materialIndex;
+  for (const override of plan.materialOverrides) for (const key of ['tint', 'roughness', 'metalness']) if (override[key] !== undefined) defaults[materialKey(key, override)] = override[key];
+  let parameters = { ...defaults };
+  const apply = (target, values, open = opened) => {
+    target.setRootTransform({ ...plan.transform, scale: values.scale }); target.setNormalization({ ...plan.normalization, unitScale: values.unitScale });
+    for (const override of plan.materialOverrides) { const current = { ...override };
+      for (const key of ['tint', 'roughness', 'metalness']) if (override[key] !== undefined) current[key] = values[materialKey(key, override)]; target.setMaterialOverride(current); }
+    for (const hinge of plan.hinges) target.setHinge(hinge.id, open.has(hinge.id) ? values['hinge:' + hinge.id] : 0);
+  };
+  instance = factory.create(); const model = instance.root, scene = new THREE.Scene(); scene.background = new THREE.Color('#dbe3e8'); scene.add(model);
+  scene.add(new THREE.HemisphereLight(0xffffff, 0x697788, 2)); const light = new THREE.DirectionalLight(0xffffff, 3); light.position.set(3, 5, 4); scene.add(light);
+  instance.setRootTransform({ ...plan.transform, scale: 1 });
+  const framing = new THREE.Box3().setFromObject(model);
+  for (const hinge of plan.hinges) {
+    for (const fraction of [.25, .5, .75, 1]) { instance.setHinge(hinge.id, hinge.openAngleDegrees * fraction); framing.union(new THREE.Box3().setFromObject(model)); }
+    instance.setHinge(hinge.id, 0);
+  }
+  const sphere = framing.getBoundingSphere(new THREE.Sphere()); apply(instance, parameters);
+  if (!Number.isFinite(sphere.radius) || sphere.radius <= 0) throw Error('model_empty_bounds');
+  const camera = new THREE.PerspectiveCamera(42, 1, Math.max(sphere.radius / 1000, .000001), sphere.radius * 1000);
+  camera.position.copy(sphere.center).add(new THREE.Vector3(3, 2, 5).normalize().multiplyScalar(sphere.radius * 4.5)); camera.lookAt(sphere.center);
+  renderer = new THREE.WebGLRenderer({ antialias: true, preserveDrawingBuffer: true }); renderer.debug.checkShaderErrors = true;
+  renderer.debug.onShaderError = () => { renderFailed = true; }; stage.append(renderer.domElement);
+  renderer.domElement.addEventListener('webglcontextlost', event => { event.preventDefault(); fail(Error('model_context_lost')); });
+  orbit = new OrbitControls(camera, renderer.domElement); orbit.target.copy(sphere.center); orbit.update();
+  let width = 0, height = 0;
+  const resize = () => { const box = stage.getBoundingClientRect(); if (box.width > 0 && box.height > 0 && (box.width !== width || box.height !== height)) {
+    width = box.width; height = box.height; renderer.setSize(width, height); camera.aspect = width / height; camera.updateProjectionMatrix(); } };
+  observer = new ResizeObserver(resize); observer.observe(stage); resize();
+  for (const hinge of plan.hinges) {
+    const button = document.createElement('button'); button.type = 'button'; button.textContent = text.open + hinge.id; button.dataset.hingeId = hinge.id;
+    button.addEventListener('click', () => { if (opened.has(hinge.id)) opened.delete(hinge.id); else opened.add(hinge.id); apply(instance, parameters); button.textContent = (opened.has(hinge.id) ? text.close : text.open) + hinge.id; }); controlsArea.append(button);
+  }
+  for (const [name, value] of Object.entries(defaults)) {
+    const label = document.createElement('label'), input = document.createElement('input'); label.textContent = (text.parameterLabels[name] ?? name) + ' '; input.dataset.modelParameter = name;
+    input.type = typeof value === 'number' ? 'number' : 'text'; if (input.type === 'number') input.step = 'any'; input.value = String(value);
+    input.addEventListener('input', () => { const next = { ...parameters, [name]: typeof value === 'number' ? Number(input.value) : input.value };
+      try { apply(instance, next); parameters = next; input.setCustomValidity(''); } catch { apply(instance, parameters); input.setCustomValidity(text.invalidParameter); } }); label.append(input); controlsArea.append(label);
+  }
+  if (!plan.hinges.length) status.textContent = text.staticModel;
+  const render = () => { if (stopped || renderFailed) throw Error('model_render_stopped'); resize(); renderer.render(scene, camera); const gl = renderer.getContext();
+    if (renderFailed || gl.isContextLost() || gl.getError() !== gl.NO_ERROR) throw Error('model_render_failed'); };
+  Object.defineProperty(window, '__PLAYCRAFT_ACCEPTANCE__', { value: Object.freeze({ schemaVersion: 1, evidenceKind: evidence.fixtureOnly ? 'fixture' : 'real-asset', binding: evidence.binding, ready,
+    THREE, renderer, scene, camera, model, sourceInspection: factory.inspection, objectsBySourceNodeId: instance.objectsBySourceNodeId, getHinge: instance.getHinge,
+    get parameters() { return Object.freeze({ ...parameters }); }, get defaultParameters() { return Object.freeze({ ...defaults }); },
+    persistence: Object.freeze({ configHash: evidence.configHash }), render,
+    create: values => { const probe = factory.create(); try { apply(probe, { ...defaults, ...values }); probes.set(probe.root, probe); return probe.root; } catch (error) { probe.dispose(); throw error; } },
+    dispose: root => { const probe = probes.get(root); if (probe) { probe.dispose(); probes.delete(root); } } }) });
+  let first = true; const draw = () => { if (stopped) return; try { render(); const box = renderer.domElement.getBoundingClientRect(), gl = renderer.getContext();
+    if (first && box.width > 0 && box.height > 0 && gl.drawingBufferWidth > 0 && gl.drawingBufferHeight > 0 && renderer.info.render.calls > 0) { first = false; resolveReady(); if (plan.hinges.length) status.textContent = text.ready; parent.postMessage({ type: 'playcraft:game-ready' }, '*'); }
+    requestAnimationFrame(draw);
+  } catch (error) { fail(error); } }; requestAnimationFrame(draw);
+} catch (error) { if (!stopped) fail(error); }
+`;
+export const modelProjectStyle = `body{margin:0;background:#eee9e0;color:#202d38;font:16px system-ui}main{max-width:1120px;margin:auto;padding:24px}#stage{height:62vh;min-height:240px;border:1px solid #c2ccd1;border-radius:8px;overflow:hidden}canvas{display:block;width:100%;height:100%}#controls{display:flex;gap:12px;flex-wrap:wrap;margin-top:16px}button,input{padding:10px 18px;border:1px solid currentColor;border-radius:4px;background:#f8f4ec;color:inherit}button{cursor:pointer}label{display:inline-flex;align-items:center;gap:8px}input{width:110px}
+`;
+export const modelProjectPrepare = String.raw `import { createHash } from 'node:crypto';
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const canonical = value => Array.isArray(value) ? '[' + value.map(canonical).join(',') + ']' : value && typeof value === 'object'
+  ? '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key])).join(',') + '}' : JSON.stringify(value);
+export async function prepareModelBuild(root) {
+  const configRaw = await readFile(join(root, '.playcraft/model-adaptation.json'), 'utf8'), plan = JSON.parse(configRaw);
+  const meta = JSON.parse(await readFile(join(root, '.playcraft/model-adaptation-lineage.json'), 'utf8'));
+  if (canonical(plan.source) !== canonical(meta.derivedSource)) throw Error('model_source_identity_changed');
+  const sourceFiles = [], evidence = { source: plan.source, configRaw, sourceFiles, fixtureOnly: meta.fixtureOnly, loaderRevision: meta.loaderRevision }; let primaryBytes;
+  for (let index = 0; index < plan.source.files.length; index++) {
+    const file = plan.source.files[index], bytes = await readFile(join(root, file.path)); if (hash(bytes) !== file.contentHash) throw Error('model_source_bytes_changed');
+    const field = file.path === plan.source.path ? 'modelBase64' : 'sourceFile' + index; evidence[field] = bytes.toString('base64'); sourceFiles.push({ ...file, field });
+    if (file.path === plan.source.path) primaryBytes = bytes;
+  }
+  const packed = await readFile(join(root, 'src/assets/packed-model.glb')); if (hash(packed) !== meta.packedHash) throw Error('model_packed_bytes_changed');
+  const core = await readFile(join(root, 'src/runtime/model-adaptation-core.js')); if (hash(core) !== meta.coreHash) throw Error('model_core_changed');
+  const inputs = []; async function walk(directory) { for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name); if (entry.isDirectory()) await walk(path); else if (entry.isFile()) inputs.push({ path: relative(root, path).split('\\').join('/'), contentHash: hash(await readFile(path)) }); else throw Error('model_input_not_regular');
+  } }
+  await walk(join(root, 'src')); await walk(join(root, 'source')); await walk(join(root, 'scripts'));
+  for (const path of ['index.html','package.json','vite.config.mjs','.playcraft/workspace.json','.playcraft/model-adaptation.json','.playcraft/model-adaptation-lineage.json','package-lock.json','pnpm-lock.yaml']) {
+    try { inputs.push({ path, contentHash: hash(await readFile(join(root, path))) }); } catch (error) { if (error.code !== 'ENOENT' || !path.endsWith('lock.json') && path !== 'pnpm-lock.yaml') throw error; }
+  }
+  inputs.sort((a,b) => a.path.localeCompare(b.path, 'en'));
+  const binding = { sourceKind: 'external-model', candidateId: meta.candidateId, sourceHash: plan.source.contentHash,
+    adaptationHash: hash(await readFile(join(root, 'src/adapter.js'))), buildHash: hash(canonical(inputs)) };
+  const packedEvidence = primaryBytes && plan.source.contentHash === meta.packedHash && primaryBytes.equals(packed)
+    ? { packedModelField: 'modelBase64' } : { packedModelBase64: packed.toString('base64') };
+  return { ...evidence, binding, configHash: hash(configRaw), packedHash: meta.packedHash, ...packedEvidence };
+}
+`;
+export const modelProjectVite = String.raw `import { defineConfig } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { prepareModelBuild } from './scripts/prepare-build.mjs';
+export default defineConfig({ base: './', plugins: [{ name: 'model-adaptation-frozen-inputs', async transformIndexHtml() {
+  const evidence = await prepareModelBuild(fileURLToPath(new URL('./', import.meta.url)));
+  return [{ tag: 'script', attrs: { id: 'playcraft-source-evidence', type: 'application/json' }, children: JSON.stringify(evidence).replace(/</g, '\\u003c'), injectTo: 'head' }];
+} }], build: { outDir: 'dist', emptyOutDir: true, assetsInlineLimit: Infinity, sourcemap: false } });
+`;

package/dist/model-adaptation/project.js

@@ -0,0 +1,76 @@
+import { lstat, mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { canonicalModelAdaptation, workspaceModelAdaptationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { inspectModelSourceFiles, modelSourceDigest } from './source.js';
+import { modelProjectAdapter, modelProjectHtml, modelProjectMain, modelProjectPrepare, modelProjectStrings, modelProjectStyle, modelProjectVite } from './project-template.js';
+export async function generateModelAdaptationProject(input) {
+    input.signal?.throwIfAborted();
+    const root = await realpath(resolve(input.projectRoot)), planPath = resolve(root, input.planPath), info = await lstat(planPath);
+    if (!info.isFile() || info.nlink !== 1 || await realpath(planPath) !== planPath || info.size > 1024 * 1024)
+        throw new Error('model_adaptation_plan_file_invalid');
+    const parentRaw = await readFile(planPath), parentPlan = workspaceModelAdaptationSchema.parse(JSON.parse(parentRaw.toString('utf8')));
+    const source = await inspectModelSourceFiles({ projectRoot: root, modelPath: parentPlan.source.path, signal: input.signal });
+    const identity = (value) => ({ ...value, files: [...value.files].sort((a, b) => a.path.localeCompare(b.path, 'en')) });
+    if (canonicalModelAdaptation(identity(source.source)) !== canonicalModelAdaptation(identity(parentPlan.source)))
+        throw new Error('model_adaptation_source_identity_mismatch');
+    if (source.metadata.unsupported.length)
+        throw new Error(`model_adaptation_rigid_source_required:${source.metadata.unsupported.join(',')}`);
+    const commonEntry = createRequire(import.meta.url).resolve('@playcraft/common/cloud-workspace/runtime');
+    const core = await readFile(join(dirname(commonEntry), 'model-adaptation-core.js')), coreHash = modelSourceDigest(core);
+    const coreMap = await readFile(join(dirname(commonEntry), 'model-adaptation-core.js.map'));
+    if (/^\s*import\s/m.test(core.toString('utf8')))
+        throw new Error('model_adaptation_core_must_be_self_contained');
+    const derivedSource = { ...parentPlan.source, path: `source/${parentPlan.source.path}`,
+        files: parentPlan.source.files.map(file => ({ ...file, path: `source/${file.path}` })) };
+    const plan = workspaceModelAdaptationSchema.parse({ ...parentPlan, source: derivedSource });
+    const candidateId = input.candidateId ?? `source-${parentPlan.source.contentHash.slice(0, 24)}`;
+    if (!/^[a-zA-Z0-9:_-]{1,128}$/.test(candidateId))
+        throw new Error('model_adaptation_candidate_id_invalid');
+    const outputRoot = resolve(input.outputRoot);
+    if (await realpath(dirname(outputRoot)) !== dirname(outputRoot))
+        throw new Error('model_adaptation_output_parent_must_be_canonical');
+    const json = (value) => JSON.stringify(value, null, 2) + '\n';
+    const files = {
+        'package.json': json({ name: 'playcraft-adapted-model-project', version: '0.0.0', private: true, type: 'module',
+            scripts: { dev: 'vite --host 0.0.0.0', build: 'vite build' }, dependencies: { three: '0.183.2', '@noble/hashes': '2.0.1' }, devDependencies: { vite: '7.1.3' } }),
+        'index.html': modelProjectHtml, 'vite.config.mjs': modelProjectVite, 'scripts/prepare-build.mjs': modelProjectPrepare,
+        'src/main.js': modelProjectMain, 'src/adapter.js': modelProjectAdapter, 'src/style.css': modelProjectStyle, 'src/strings.json': json(modelProjectStrings),
+        '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,
+            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: {
+                schemaVersion: { type: 'number', readOnly: true }, source: { type: 'object', readOnly: true },
+                normalization: { type: 'object', properties: { unitScale: { type: 'number', minimum: .000000001, maximum: 1000000000, title: 'Unit scale' }, rotationDegrees: { type: 'array', readOnly: true } } },
+                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',
+        '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/') ||
+        ['index.html', 'package.json', 'vite.config.mjs', '.playcraft/workspace.json', '.playcraft/model-adaptation.json', '.playcraft/model-adaptation-lineage.json'].includes(path));
+    if (derivedSource.files.length + adaptationPaths.length > 256 || adaptationPaths.length > 64)
+        throw new Error('model_adaptation_build_input_bound');
+    files['.playcraft/model-build-inputs.json'] = json({ schemaVersion: 1, models: [{ source: derivedSource, adaptationFiles: adaptationPaths.map(path => ({ path })) }] });
+    for (const [path, bytes] of source.originalFiles)
+        files[`source/${path}`] = bytes;
+    const manifest = { schemaVersion: 1, fixtureOnly: input.fixtureOnly === true, source: parentPlan.source, derivedSource,
+        parentPlanHash: modelSourceDigest(parentRaw), coreHash, packedHash: source.packedHash,
+        files: Object.entries(files).map(([path, bytes]) => ({ path, contentHash: modelSourceDigest(bytes), bytes: typeof bytes === 'string' ? Buffer.byteLength(bytes) : bytes.byteLength }))
+            .sort((a, b) => a.path.localeCompare(b.path, 'en')),
+        geometryValidation: 'pending-runtime', modelInference: false, modelAcceptance: false, publicationAcceptance: false };
+    files['model-adaptation-source-manifest.json'] = json(manifest);
+    input.signal?.throwIfAborted();
+    await mkdir(outputRoot, { recursive: false });
+    for (const [path, bytes] of Object.entries(files)) {
+        input.signal?.throwIfAborted();
+        const absolute = join(outputRoot, path);
+        await mkdir(dirname(absolute), { recursive: true });
+        await writeFile(absolute, bytes, { flag: 'wx' });
+    }
+    return { outputRoot, manifest };
+}

package/dist/model-adaptation/source.js

@@ -0,0 +1,49 @@
+import { createHash } from 'node:crypto';
+import { lstat, readFile, realpath } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { packModelSource, readModelSourceDocument, resolveModelDependencyPath, workspaceRelativePathSchema } from '@playcraft/common/cloud-workspace/runtime';
+export const modelSourceDigest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export async function readModelSourceFile(root, path) {
+    workspaceRelativePathSchema.parse(path);
+    if (path.split('/').some(part => ['.git', '.playcraft', '.ssh', 'node_modules'].includes(part) || part === '.env' || part.startsWith('.env.')))
+        throw new Error('model_source_path_unsafe');
+    const absolute = resolve(root, path), rel = relative(root, absolute);
+    if (rel.startsWith(`..${sep}`) || isAbsolute(rel) || await realpath(absolute) !== absolute)
+        throw new Error('model_source_path_unsafe');
+    const stat = await lstat(absolute);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > 64 * 1024 * 1024)
+        throw new Error('model_source_file_bound');
+    return new Uint8Array(await readFile(absolute));
+}
+/** Source metadata only: runtime geometry identities always come from the shared actual-engine inspector. */
+export async function inspectModelSourceFiles(input) {
+    const root = await realpath(resolve(input.projectRoot)), path = relative(root, resolve(root, input.modelPath)).split(sep).join('/');
+    workspaceRelativePathSchema.parse(path);
+    if (!/\.(?:glb|gltf)$/i.test(path))
+        throw new Error('model_source_format_unsupported');
+    const bytes = await readModelSourceFile(root, path), sourceDocument = readModelSourceDocument(bytes).document;
+    const originalFiles = new Map([[path, bytes]]);
+    const packed = await packModelSource({ path, bytes, signal: input.signal, digestBytes: modelSourceDigest,
+        readDependency: async (uri) => {
+            const dependencyPath = resolveModelDependencyPath(uri, path), data = await readModelSourceFile(root, dependencyPath);
+            originalFiles.set(dependencyPath, data);
+            return { path: dependencyPath, bytes: data };
+        } });
+    const source = { kind: 'resource', path, contentHash: modelSourceDigest(bytes), files: packed.sourceFiles };
+    const list = (value) => Array.isArray(value) ? value : [];
+    const rawNodes = list(sourceDocument.nodes);
+    const meshes = list(sourceDocument.meshes);
+    const unsupported = [
+        ...(list(sourceDocument.animations).length ? ['animation'] : []), ...(list(sourceDocument.skins).length ? ['skinned_mesh'] : []),
+        ...(rawNodes.some(node => node.extensions?.EXT_mesh_gpu_instancing) ? ['instanced_mesh'] : []),
+        ...(meshes.some(mesh => mesh.primitives?.some(primitive => primitive.targets?.length)) ? ['morph_targets'] : []),
+        ...(rawNodes.length > 4096 ? ['node_bound'] : []),
+    ];
+    const metadata = { format: /\.glb$/i.test(path) ? 'glb' : 'gltf', nodes: list(sourceDocument.nodes).length,
+        meshes: list(sourceDocument.meshes).length, materials: list(sourceDocument.materials).length,
+        animations: list(sourceDocument.animations).length, skins: list(sourceDocument.skins).length,
+        extensionsUsed: list(sourceDocument.extensionsUsed), unsupported, geometryIdentity: 'requires-runtime-inspection',
+        sourceNodes: rawNodes.slice(0, 4096).map((node, gltfNodeIndex) => ({ gltfNodeIndex, name: node.name ?? '', mesh: node.mesh, children: node.children ?? [] })) };
+    return { source, packed: packed.glb, packedHash: packed.packedHash, originalFiles, metadata,
+        modelInference: false, acceptance: false };
+}