@playcraft/cli 0.1.60-beta → 0.1.62-beta

package/dist/workspace-runtime/workspaces/procedural-3d/read-candidates.js

@@ -0,0 +1,219 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { workspaceModelCandidateListSchema, workspaceModelCandidateSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { checkedFile, dependencyHash, digest, relativeFile } from './files.js';
+import { ModelPreviewStore } from './model-preview-store.js';
+const hash = z.string().regex(/^[a-f0-9]{64}$/);
+const fileSchema = z.object({ path: z.string().refine(value => {
+        try {
+            relativeFile(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }), hash });
+const candidateSchema = z.object({ id: z.string().uuid(), files: z.array(fileSchema).min(1).max(256),
+    sourcePaths: z.array(z.string()).min(1).max(128), sourceHash: hash, dependencyHash: hash,
+    pagePath: z.string(), specHash: hash, passId: z.string().min(1).max(128),
+    captures: z.array(fileSchema.extend({ view: z.string().min(1).max(64) })).max(16).optional(),
+    hostReview: z.object({ profileHash: hash }).optional(),
+    review: z.object({ decision: z.enum(['accept', 'revise']), sourceHash: hash }).optional(),
+    adoptedPath: z.string().optional() });
+const runSchema = z.object({ schemaVersion: z.literal(1), runId: z.string().uuid(),
+    revision: z.number().int().nonnegative(), root: z.string(), artifactHash: hash,
+    referenceHash: hash, referencePath: z.string(), candidates: z.array(z.unknown()) });
+const MAX_RUNS = 64;
+const MAX_CANDIDATES = 128;
+const MAX_BYTES = 256 * 1024 * 1024;
+/** Read control-owned snapshots without invoking the Skill or changing a completed run. */
+export async function readProceduralModelCandidates(root, stateDir) {
+    const result = { schemaVersion: 1, candidates: [], diagnostics: [],
+        truncated: false, scannedAt: new Date().toISOString() };
+    const controlRelative = `procedural-3d/${digest(root)}`;
+    const controlDirectory = join(stateDir, controlRelative);
+    const diagnose = (code, runId, candidateId) => {
+        if (result.diagnostics.length < 256)
+            result.diagnostics.push({ code, ...(runId ? { runId } : {}), ...(candidateId ? { candidateId } : {}) });
+        else
+            result.truncated = true;
+    };
+    let names;
+    try {
+        const info = await lstat(controlDirectory);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error('model_candidates_control_invalid');
+        names = (await readdir(controlDirectory)).filter(name => /^[a-f0-9-]{36}\.json$/i.test(name)).sort();
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            diagnose('model_candidates_control_unavailable');
+        return result;
+    }
+    if (names.length > MAX_RUNS) {
+        result.truncated = true;
+        diagnose('model_candidates_run_limit');
+    }
+    let inspectedBytes = 0;
+    let inspectedCandidates = 0;
+    const seenCandidates = new Set();
+    const readBounded = async (base, path) => {
+        if (inspectedBytes >= MAX_BYTES)
+            throw new Error('model_candidates_byte_limit');
+        const bytes = await checkedFile(base, path, Math.min(16 * 1024 * 1024, MAX_BYTES - inspectedBytes));
+        inspectedBytes += bytes.length;
+        return bytes;
+    };
+    let currentDependencyHash;
+    try {
+        currentDependencyHash = await dependencyHash(root);
+    }
+    catch { /* Each candidate remains visible with a diagnostic. */ }
+    for (const name of names.slice(0, MAX_RUNS)) {
+        const runId = name.slice(0, -5);
+        if (!z.string().uuid().safeParse(runId).success) {
+            diagnose('model_candidates_run_invalid');
+            continue;
+        }
+        let run;
+        try {
+            run = runSchema.parse(JSON.parse((await checkedFile(stateDir, `${controlRelative}/${name}`, 4 * 1024 * 1024)).toString('utf8')));
+            if (run.root !== root || run.runId !== runId)
+                throw new Error('model_candidates_scope_mismatch');
+        }
+        catch {
+            diagnose('model_candidates_run_invalid', runId);
+            continue;
+        }
+        const jobRelative = `.playcraft/procedural-3d/runs/${runId}`;
+        const jobRoot = join(root, jobRelative);
+        let referenceVerified = false;
+        try {
+            referenceVerified = digest(await readBounded(jobRoot, run.referencePath)) === run.referenceHash;
+        }
+        catch { /* Reported against every affected candidate, without exposing filesystem errors. */ }
+        for (const raw of run.candidates) {
+            if (inspectedCandidates++ >= MAX_CANDIDATES) {
+                result.truncated = true;
+                diagnose('model_candidates_candidate_limit', runId);
+                break;
+            }
+            if (result.candidates.length >= MAX_CANDIDATES) {
+                result.truncated = true;
+                diagnose('model_candidates_candidate_limit', runId);
+                break;
+            }
+            const parsed = candidateSchema.safeParse(raw);
+            if (!parsed.success) {
+                diagnose('model_candidates_candidate_invalid', runId);
+                continue;
+            }
+            const candidate = parsed.data;
+            if (seenCandidates.has(`${runId}:${candidate.id}`)) {
+                diagnose('model_candidates_candidate_duplicate', runId, candidate.id);
+                continue;
+            }
+            seenCandidates.add(`${runId}:${candidate.id}`);
+            const candidatePrefix = `${jobRelative}/candidates/${candidate.id}`;
+            const source = new Set(candidate.sourcePaths);
+            try {
+                relativeFile(candidate.pagePath);
+                if (candidate.adoptedPath)
+                    relativeFile(candidate.adoptedPath);
+                if (new Set(candidate.files.map(file => file.path)).size !== candidate.files.length ||
+                    new Set(candidate.captures?.map(file => file.path)).size !== (candidate.captures?.length ?? 0) ||
+                    candidate.sourcePaths.some(path => !candidate.files.some(file => file.path === path)) ||
+                    !candidate.files.some(file => file.path === candidate.pagePath) ||
+                    candidate.captures?.some(file => !file.path.startsWith(`candidates/${candidate.id}/captures/`)))
+                    throw new Error('model_candidates_manifest_invalid');
+            }
+            catch {
+                diagnose('model_candidates_manifest_invalid', runId, candidate.id);
+                continue;
+            }
+            const item = {
+                runId, candidateId: candidate.id, revision: run.revision, passId: candidate.passId,
+                sourceHash: candidate.sourceHash, dependencyHash: candidate.dependencyHash,
+                referenceHash: run.referenceHash, skillArtifactHash: run.artifactHash,
+                files: candidate.files.map(file => ({ path: `${candidatePrefix}/source/${file.path}`, contentHash: file.hash, source: source.has(file.path) })),
+                captures: (candidate.captures ?? []).map(file => ({ path: `${jobRelative}/${file.path}`, contentHash: file.hash, view: file.view })),
+                preview: { kind: 'scene-preview', status: 'needs-build', entryPath: `${candidatePrefix}/source/${candidate.pagePath}`,
+                    sourceHash: candidate.sourceHash, dependencyHash: candidate.dependencyHash,
+                    ...(candidate.hostReview ? { profileHash: candidate.hostReview.profileHash } : {}), reason: 'candidate_scene_not_built' },
+                integrity: 'verified', ...(candidate.review ? { review: candidate.review } : {}),
+                ...(candidate.adoptedPath ? { adoptedPath: candidate.adoptedPath } : {}),
+            };
+            const invalidate = (code) => {
+                item.integrity = 'invalid';
+                if (item.preview.kind === 'scene-preview') {
+                    item.preview.status = 'unavailable';
+                    item.preview.reason = code;
+                }
+                diagnose(code, runId, candidate.id);
+            };
+            if (!workspaceModelCandidateSchema.safeParse(item).success) {
+                diagnose('model_candidates_manifest_invalid', runId, candidate.id);
+                continue;
+            }
+            if (!referenceVerified)
+                invalidate('model_candidates_reference_changed');
+            if (currentDependencyHash !== candidate.dependencyHash)
+                invalidate('model_candidates_dependencies_changed');
+            if (digest(JSON.stringify(candidate.files.map(({ path, hash }) => ({ path, hash })))) !== candidate.sourceHash)
+                invalidate('model_candidates_source_hash_changed');
+            if (!candidate.captures?.length)
+                invalidate('model_candidates_captures_missing');
+            if (candidate.review && candidate.review.sourceHash !== candidate.sourceHash)
+                invalidate('model_candidates_review_changed');
+            try {
+                if (digest(await readBounded(root, `${candidatePrefix}/spec.json`)) !== candidate.specHash)
+                    invalidate('model_candidates_spec_changed');
+            }
+            catch {
+                invalidate('model_candidates_spec_unavailable');
+            }
+            for (const file of [...item.files, ...item.captures]) {
+                try {
+                    const bytes = await readBounded(root, file.path);
+                    file.size = bytes.length;
+                    if (digest(bytes) !== file.contentHash)
+                        throw new Error('model_candidates_file_changed');
+                }
+                catch (error) {
+                    const limit = inspectedBytes >= MAX_BYTES || (error instanceof Error && error.message === 'model_candidates_byte_limit');
+                    invalidate(limit ? 'model_candidates_byte_limit' : 'model_candidates_file_unavailable');
+                    if (limit) {
+                        result.truncated = true;
+                        break;
+                    }
+                }
+            }
+            result.candidates.push(item);
+            if (item.integrity === 'verified' && item.preview.kind === 'scene-preview') {
+                try {
+                    const versions = await new ModelPreviewStore(stateDir, root).versions(item), preview = versions[0];
+                    item.previewVersions = versions.map(version => ({ previewId: version.previewId, contentHash: version.contentHash,
+                        createdAt: version.createdAt, ...(version.parameters ? { parameters: version.parameters } : {}),
+                        ...(version.parameterHash ? { parameterHash: version.parameterHash } : {}) }));
+                    if (preview)
+                        Object.assign(item.preview, { status: 'ready', reason: 'candidate_scene_built',
+                            previewId: preview.previewId, contentHash: preview.contentHash,
+                            ...(preview.parameters ? { parameters: preview.parameters } : {}),
+                            ...(preview.parameterHash ? { parameterHash: preview.parameterHash } : {}) });
+                }
+                catch {
+                    invalidate('model_preview_receipt_invalid');
+                }
+            }
+            if (inspectedBytes >= MAX_BYTES)
+                break;
+        }
+        if (inspectedBytes >= MAX_BYTES || inspectedCandidates >= MAX_CANDIDATES) {
+            result.truncated = true;
+            diagnose(inspectedBytes >= MAX_BYTES ? 'model_candidates_byte_limit' : 'model_candidates_candidate_limit', runId);
+            break;
+        }
+    }
+    return workspaceModelCandidateListSchema.parse(result);
+}

package/dist/workspace-runtime/workspaces/procedural-3d/render-worker.js

@@ -0,0 +1,159 @@
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { chromium } from 'playwright-core';
+import sharp from 'sharp';
+import { digest } from './files.js';
+import { canonicalJson, reviewProfileHash, validateRenderState, } from './review-contracts.js';
+/** Launched as the development user; Vite and Chromium die with the managed process group. */
+async function main() {
+    let raw = '';
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+        if (raw.length > 64 * 1024)
+            throw new Error('render_input_limit');
+    }
+    const input = JSON.parse(raw);
+    if (input.reviewProfile &&
+        reviewProfileHash(input.reviewProfile.profile) !== input.reviewProfile.hash)
+        throw new Error('render_profile_mismatch');
+    const project = createRequire(join(input.projectRoot, 'package.json'));
+    const vite = await import(pathToFileURL(project.resolve('vite')).href);
+    const three = join(dirname(project.resolve('three')), 'three.module.js');
+    const threeVersion = JSON.parse(await readFile(join(dirname(three), '../package.json'), 'utf8')).version;
+    const server = await vite.createServer({
+        configFile: false,
+        root: input.sourceRoot,
+        logLevel: 'silent',
+        resolve: { alias: [{ find: /^three$/, replacement: three }] },
+        server: {
+            host: '127.0.0.1',
+            port: 0,
+            strictPort: false,
+            fs: { strict: true, allow: [input.sourceRoot, dirname(three)] },
+        },
+    });
+    let browser;
+    try {
+        await server.listen();
+        const address = server.httpServer.address();
+        const origin = `http://127.0.0.1:${address.port}`;
+        browser = await chromium.launch({
+            executablePath: process.env.PLAYCRAFT_CHROMIUM_PATH || '/usr/bin/chromium',
+            headless: true,
+            args: [
+                '--disable-dev-shm-usage',
+                '--enable-unsafe-swiftshader',
+                '--use-gl=angle',
+                '--use-angle=swiftshader',
+            ],
+        });
+        const context = await browser.newContext({
+            viewport: { width: 768, height: 768 },
+            deviceScaleFactor: 1,
+            serviceWorkers: 'block',
+        });
+        const errors = [];
+        await context.route('**/*', (route) => {
+            const url = route.request().url();
+            if (url === `${origin}/favicon.ico`)
+                return route.fulfill({ status: 204 });
+            return url.startsWith(`${origin}/`) || /^(data|blob):/.test(url)
+                ? route.continue()
+                : route.abort('blockedbyclient');
+        });
+        const page = await context.newPage();
+        page.on('pageerror', (error) => errors.push(error.message));
+        page.on('console', (message) => {
+            if (message.type() === 'error')
+                errors.push(message.text());
+        });
+        page.on('requestfailed', (request) => errors.push(`${request.url()}: ${request.failure()?.errorText}`));
+        await page.goto(`${origin}/${input.pagePath.split('/').map(encodeURIComponent).join('/')}`, {
+            waitUntil: 'networkidle',
+            timeout: 30_000,
+        });
+        await page.waitForFunction('Boolean(window.__PLAYCRAFT_SCULPT__?.ready)', undefined, {
+            timeout: 30_000,
+        });
+        await page.evaluate('Promise.resolve(window.__PLAYCRAFT_SCULPT__.ready)');
+        const renderer = await page.evaluate(`(() => {const c=document.querySelector('canvas'); const g=c?.getContext('webgl2')||c?.getContext('webgl'); if(!g) throw new Error('webgl_unavailable'); const e=g.getExtension('WEBGL_debug_renderer_info'); return {renderer:g.getParameter(e?e.UNMASKED_RENDERER_WEBGL:g.RENDERER),vendor:g.getParameter(e?e.UNMASKED_VENDOR_WEBGL:g.VENDOR)};})()`);
+        await mkdir(input.outputRoot, { recursive: true });
+        const captures = [];
+        const states = {};
+        const captureState = async (view, stripped = false) => {
+            if (!input.reviewProfile)
+                return;
+            states[view] = validateRenderState(await page.evaluate('window.__PLAYCRAFT_SCULPT__.getRenderState()'), input.reviewProfile.profile, view, stripped);
+        };
+        for (const view of input.views) {
+            await page.evaluate(`Promise.resolve(window.__PLAYCRAFT_SCULPT__.setView(${JSON.stringify(view)})).then(()=>new Promise(r=>requestAnimationFrame(()=>requestAnimationFrame(r))))`);
+            await page.screenshot({
+                path: join(input.outputRoot, `${view}.png`),
+                animations: 'disabled',
+            });
+            await captureState(view);
+            captures.push({ view, file: `${view}.png` });
+        }
+        await page.evaluate(`Promise.resolve(window.__PLAYCRAFT_SCULPT__.setView('hero')).then(()=>window.__PLAYCRAFT_SCULPT__.setMapStripped(true)).then(()=>new Promise(r=>requestAnimationFrame(()=>requestAnimationFrame(r))))`);
+        await page.screenshot({
+            path: join(input.outputRoot, 'map-stripped.png'),
+            animations: 'disabled',
+        });
+        captures.push({ view: 'map-stripped', file: 'map-stripped.png' });
+        await captureState('map-stripped', true);
+        const reference = await sharp(input.referencePath)
+            .resize(768, 768, { fit: 'contain', background: '#e9e9e9' })
+            .png()
+            .toBuffer();
+        const hero = await sharp(join(input.outputRoot, `${input.views.includes('hero') ? 'hero' : input.views[0]}.png`))
+            .resize(768, 768)
+            .png()
+            .toBuffer();
+        await sharp({ create: { width: 1536, height: 768, channels: 3, background: '#e9e9e9' } })
+            .composite([
+            { input: reference, left: 0, top: 0 },
+            { input: hero, left: 768, top: 0 },
+        ])
+            .png()
+            .toFile(join(input.outputRoot, 'comparison.png'));
+        captures.push({ view: 'comparison', file: 'comparison.png' });
+        let renderReceipt;
+        if (input.reviewProfile) {
+            const bytes = canonicalJson({
+                schemaVersion: 1,
+                reviewProfileHash: input.reviewProfile.hash,
+                profile: input.reviewProfile.profile,
+                views: states,
+            });
+            await writeFile(join(input.outputRoot, 'render-state.json'), bytes, { flag: 'wx' });
+            renderReceipt = { file: 'render-state.json', hash: digest(bytes) };
+        }
+        await page.evaluate('window.__PLAYCRAFT_SCULPT__.dispose?.()');
+        if (errors.length)
+            throw new Error(`render_errors: ${errors.join('\n').slice(0, 4000)}`);
+        return {
+            captures,
+            renderer,
+            browser: browser.version(),
+            node: process.version,
+            three: threeVersion,
+            vite: vite.version,
+            viewport: { width: 768, height: 768, deviceScaleFactor: 1 },
+            ready: true,
+            ...(renderReceipt ? { renderReceipt } : {}),
+            errors,
+        };
+    }
+    finally {
+        await browser?.close();
+        await server.close();
+    }
+}
+main()
+    .then((result) => process.stdout.write(JSON.stringify({ ok: true, result })))
+    .catch((error) => {
+    process.stderr.write(String(error));
+    process.exitCode = 1;
+});

package/dist/workspace-runtime/workspaces/procedural-3d/review-contracts.js

@@ -0,0 +1,257 @@
+import { z } from 'zod';
+import { digest, relativeFile } from './files.js';
+export const REVIEW_DIRECTORY = '__playcraft-review';
+export const REVIEW_PAGE = `${REVIEW_DIRECTORY}/index.html`;
+export const REVIEW_VIEWS = ['front', 'right', 'back', 'left', 'hero'];
+const finite = z.number().finite();
+const coordinate = finite.min(-100000).max(100000);
+const vector = z.tuple([coordinate, coordinate, coordinate]);
+const projectedVector = z.tuple([finite, finite, finite]);
+const matrix = z.array(finite).length(16);
+export const reviewProfileSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    fovDegrees: finite.min(1).max(120),
+    near: finite.min(0.0001).max(1000),
+    far: finite.max(100000),
+    target: vector,
+    views: z
+        .object({ front: vector, right: vector, back: vector, left: vector, hero: vector })
+        .strict(),
+    background: z
+        .string()
+        .regex(/^#[a-fA-F0-9]{6}$/)
+        .transform((value) => value.toLowerCase()),
+    keyLightPosition: vector,
+    referenceCameraStatus: z.literal('estimated'),
+})
+    .strict()
+    .superRefine((profile, context) => {
+    if (profile.far < profile.near + 0.0001)
+        context.addIssue({ code: z.ZodIssueCode.custom, message: 'invalid camera range' });
+    for (const position of Object.values(profile.views)) {
+        const distance = Math.hypot(...position.map((value, index) => value - profile.target[index]));
+        if (distance <= profile.near || distance >= profile.far)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'invalid camera target distance',
+            });
+    }
+});
+/** A bounded canonical JSON (JavaScript Object Notation, JavaScript对象表示法) encoding. */
+export function canonicalJson(value) {
+    let nodes = 0;
+    const normalize = (input, depth = 0) => {
+        if (++nodes > 4096 || depth > 12)
+            throw new Error('procedural_skill_invalid_review_json');
+        if (input === null || typeof input === 'string' || typeof input === 'boolean')
+            return input;
+        if (typeof input === 'number' && Number.isFinite(input))
+            return input;
+        if (Array.isArray(input))
+            return input.map((item) => normalize(item, depth + 1));
+        if (input && typeof input === 'object' && Object.getPrototypeOf(input) === Object.prototype)
+            return Object.fromEntries(Object.keys(input)
+                .sort()
+                .map((key) => [key, normalize(input[key], depth + 1)]));
+        throw new Error('procedural_skill_invalid_review_json');
+    };
+    const encoded = JSON.stringify(normalize(value));
+    if (Buffer.byteLength(encoded) > 64 * 1024)
+        throw new Error('procedural_skill_invalid_review_json');
+    return encoded;
+}
+export const reviewProfileHash = (profile) => digest(canonicalJson(profile));
+export const captureV2Schema = z
+    .object({
+    files: z.array(z.string()).min(1).max(252),
+    sourcePaths: z.array(z.string()).min(1).max(128),
+    views: z.array(z.enum(REVIEW_VIEWS)).min(3).max(5).default(['front', 'right', 'hero']),
+    review: z
+        .object({
+        factoryPath: z.string(),
+        exportName: z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,79}$/),
+        parameters: z.record(z.unknown()).optional(),
+        profile: reviewProfileSchema,
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    const invalid = () => context.addIssue({ code: z.ZodIssueCode.custom, message: 'invalid controlled review input' });
+    if (new Set(input.views).size !== input.views.length || !input.views.includes('hero'))
+        invalid();
+    if (!input.sourcePaths.includes(input.review.factoryPath) ||
+        !/\.(?:[cm]?[jt]sx?)$/.test(input.review.factoryPath))
+        invalid();
+    if (input.files.some((path) => path.toLowerCase() === REVIEW_DIRECTORY ||
+        path.toLowerCase().startsWith(`${REVIEW_DIRECTORY}/`)))
+        invalid();
+    try {
+        relativeFile(input.review.factoryPath);
+        if (input.review.parameters &&
+            Buffer.byteLength(canonicalJson(input.review.parameters)) > 16 * 1024)
+            invalid();
+    }
+    catch {
+        invalid();
+    }
+});
+const renderStateSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    view: z.enum(REVIEW_VIEWS),
+    mapStripped: z.boolean(),
+    profile: reviewProfileSchema,
+    viewport: z
+        .object({ width: z.literal(768), height: z.literal(768), deviceScaleFactor: z.literal(1) })
+        .strict(),
+    camera: z
+        .object({
+        position: vector,
+        target: vector,
+        fovDegrees: finite,
+        near: finite,
+        far: finite,
+        projectionMatrix: matrix,
+        matrixWorld: matrix,
+        matrixWorldInverse: matrix,
+    })
+        .strict(),
+    modelBounds: z.object({ min: vector, max: vector }).strict(),
+    projectedBounds: z
+        .object({ min: projectedVector, max: projectedVector, conservative: z.literal(true) })
+        .strict()
+        .nullable(),
+    framing: z.enum(['contained', 'bounds-overflow', 'unknown']),
+})
+    .strict();
+const close = (a, b) => Math.abs(a - b) <= 1e-7 * Math.max(1, Math.abs(a), Math.abs(b));
+const same = (a, b) => a.length === b.length && a.every((value, index) => close(value, b[index]));
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const norm = (a) => {
+    const length = Math.hypot(...a);
+    return a.map((value) => value / length);
+};
+const dot = (a, b) => a.reduce((sum, value, index) => sum + value * b[index], 0);
+/** Independently check the actual helper state against the fixed camera, never fit model bounds. */
+export function validateRenderState(value, profile, view, stripped = false) {
+    const state = renderStateSchema.parse(value);
+    const expectedView = stripped ? 'hero' : view;
+    const position = profile.views[expectedView];
+    const fail = () => {
+        throw new Error('procedural_skill_review_state_mismatch');
+    };
+    if (!position ||
+        state.view !== expectedView ||
+        state.mapStripped !== stripped ||
+        canonicalJson(state.profile) !== canonicalJson(profile) ||
+        !same(state.camera.position, position) ||
+        !same(state.camera.target, profile.target) ||
+        !close(state.camera.fovDegrees, profile.fovDegrees) ||
+        !close(state.camera.near, profile.near) ||
+        !close(state.camera.far, profile.far))
+        fail();
+    let zAxis = norm(position.map((value, index) => value - profile.target[index]));
+    if (Math.hypot(...cross([0, 1, 0], zAxis)) === 0) {
+        zAxis[2] += 0.0001;
+        zAxis = norm(zAxis);
+    }
+    const xAxis = norm(cross([0, 1, 0], zAxis)), yAxis = cross(zAxis, xAxis);
+    const world = [...xAxis, 0, ...yAxis, 0, ...zAxis, 0, ...position, 1];
+    const inverse = [
+        xAxis[0],
+        yAxis[0],
+        zAxis[0],
+        0,
+        xAxis[1],
+        yAxis[1],
+        zAxis[1],
+        0,
+        xAxis[2],
+        yAxis[2],
+        zAxis[2],
+        0,
+        -dot(xAxis, position),
+        -dot(yAxis, position),
+        -dot(zAxis, position),
+        1,
+    ];
+    const scale = 1 / Math.tan((profile.fovDegrees * Math.PI) / 360);
+    const projection = [
+        scale,
+        0,
+        0,
+        0,
+        0,
+        scale,
+        0,
+        0,
+        0,
+        0,
+        -(profile.far + profile.near) / (profile.far - profile.near),
+        -1,
+        0,
+        0,
+        (-2 * profile.far * profile.near) / (profile.far - profile.near),
+        0,
+    ];
+    if (!same(state.camera.matrixWorld, world) ||
+        !same(state.camera.matrixWorldInverse, inverse) ||
+        !same(state.camera.projectionMatrix, projection))
+        fail();
+    if (state.modelBounds.min.some((entry, index) => entry > state.modelBounds.max[index]))
+        fail();
+    const multiply = (m, p) => [0, 1, 2, 3].map((row) => p.reduce((sum, entry, column) => sum + m[column * 4 + row] * entry, 0));
+    const points = [];
+    for (const x of [state.modelBounds.min[0], state.modelBounds.max[0]])
+        for (const y of [state.modelBounds.min[1], state.modelBounds.max[1]])
+            for (const z of [state.modelBounds.min[2], state.modelBounds.max[2]]) {
+                const clip = multiply(projection, multiply(inverse, [x, y, z, 1]));
+                if (!clip.every(Number.isFinite) || clip[3] <= 1e-9) {
+                    if (state.projectedBounds !== null || state.framing !== 'unknown')
+                        fail();
+                    return state;
+                }
+                points.push(clip.slice(0, 3).map((entry) => entry / clip[3]));
+            }
+    const min = [0, 1, 2].map((axis) => Math.min(...points.map((point) => point[axis])));
+    const max = [0, 1, 2].map((axis) => Math.max(...points.map((point) => point[axis])));
+    const framing = min.every((value) => value >= -1) && max.every((value) => value <= 1)
+        ? 'contained'
+        : 'bounds-overflow';
+    if (!state.projectedBounds ||
+        !same(state.projectedBounds.min, min) ||
+        !same(state.projectedBounds.max, max) ||
+        state.framing !== framing)
+        fail();
+    return state;
+}
+export function validateRenderReceipt(value, profile, views) {
+    const receipt = z
+        .object({
+        schemaVersion: z.literal(1),
+        reviewProfileHash: z.string().regex(/^[a-f0-9]{64}$/),
+        profile: reviewProfileSchema,
+        views: z.record(z.unknown()),
+    })
+        .strict()
+        .parse(value);
+    const expected = [...views, 'map-stripped'];
+    if (receipt.reviewProfileHash !== reviewProfileHash(profile) ||
+        canonicalJson(receipt.profile) !== canonicalJson(profile) ||
+        Object.keys(receipt.views).length !== expected.length ||
+        expected.some((view) => !Object.hasOwn(receipt.views, view)))
+        throw new Error('procedural_skill_review_receipt_mismatch');
+    return {
+        ...receipt,
+        views: Object.fromEntries(expected.map((view) => [
+            view,
+            validateRenderState(receipt.views[view], profile, view, view === 'map-stripped'),
+        ])),
+    };
+}

package/dist/workspace-runtime/workspaces/procedural-3d/review-page.js

@@ -0,0 +1,26 @@
+import { canonicalJson, REVIEW_DIRECTORY, REVIEW_PAGE, } from './review-contracts.js';
+const literal = (value) => JSON.stringify(value)
+    .replace(/</g, '\\u003c')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+/** Only locked helpers and declarative factory data enter the host-owned review page. */
+export function createHostReviewFiles(review, helpers) {
+    const factory = `/${review.factoryPath.split('/').map(encodeURIComponent).join('/')}`;
+    const profile = canonicalJson(review.profile);
+    const page = `<!doctype html><html><head><meta charset="utf-8"><base href="/"><style>html,body{margin:0;width:768px;height:768px;overflow:hidden}</style></head><body><script type="module">
+import { createReviewScene } from '/${REVIEW_DIRECTORY}/review-scene.mjs';
+import * as factory from ${literal(factory)};
+const createModel = factory[${literal(review.exportName)}];
+if (typeof createModel !== 'function') throw new Error('review_factory_missing');
+const parameters = JSON.parse(${literal(canonicalJson(review.parameters ?? {}))});
+const profile = JSON.parse(${literal(profile)});
+const api = createReviewScene(() => createModel(parameters), { profile });
+Object.defineProperty(window, '__PLAYCRAFT_SCULPT__', { value: api, writable: false, configurable: false });
+</script></body></html>`;
+    return [
+        { path: REVIEW_PAGE, bytes: Buffer.from(page) },
+        { path: `${REVIEW_DIRECTORY}/review-scene.mjs`, bytes: helpers.scene },
+        { path: `${REVIEW_DIRECTORY}/review-profile.mjs`, bytes: helpers.profile },
+        { path: `${REVIEW_DIRECTORY}/profile.json`, bytes: Buffer.from(profile) },
+    ];
+}