@playcraft/cli 0.1.66 → 0.1.68

package/dist/workspace-runtime/workspaces/audio-assets/library-import.js

@@ -0,0 +1,149 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, open, readdir, readFile, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { canonicalAudioJson, audioRepresentationSetHash, inspectAudioLibrarySnapshot, audioLibraryOriginSchema, audioLibraryPayloadHash } from '@playcraft/common/cloud-workspace/runtime';
+import { audioRendererScript } from './renderer.js';
+import { readAudioArtifactPackage } from './artifact-package.js';
+import { audioProjectPath, audioError, digest } from './storage.js';
+import { ensureSharedDirectory, writeSharedFile } from '../shared-write.js';
+export const isEditableAudioLibraryAsset = (asset) => {
+    if (asset.files.some(file => /(?:^|\/)sound\.(?:pcaudio|pcscore)\.json$/.test(file.path)))
+        return true;
+    try {
+        const file = asset.files.find(file => file.path === 'manifest.json');
+        const value = file && JSON.parse(Buffer.from(file.content, 'base64').toString('utf8'));
+        return Boolean(value && (value.sourcePath !== undefined || value.representationSetHash !== undefined));
+    }
+    catch {
+        return false;
+    }
+};
+function inspectAsset(asset, requirePlatformProof = true) {
+    if (requirePlatformProof && !asset.audioSource)
+        throw audioError('audio_library_source_unverified', 409);
+    try {
+        const manifestFile = asset.files.find(file => file.path === 'manifest.json');
+        if (!manifestFile)
+            throw new Error();
+        const manifest = JSON.parse(Buffer.from(manifestFile.content, 'base64').toString('utf8'));
+        const checked = inspectAudioLibrarySnapshot({ version: 1, target: asset.audioSource?.source.target ?? { kind: 'workspace-file', path: manifest.sourcePath },
+            revision: asset.audioSource?.source.revision ?? 1, sourcePath: manifest.sourcePath,
+            files: asset.files.map(file => ({ path: file.path, mimeType: file.mimeType, content: file.content,
+                contentHash: file.sha256, size: Buffer.from(file.content, 'base64').length })) });
+        if (asset.audioSource && audioLibraryPayloadHash(checked.source) !== audioLibraryPayloadHash(asset.audioSource.source))
+            throw new Error();
+        return checked;
+    }
+    catch {
+        throw audioError('invalid_audio_library_package', 400);
+    }
+}
+async function trustedEngine(checked) {
+    const engine = await audioRendererScript(checked.document.format === 'playcraft.score' ? 'score' : 'synth-sfx');
+    const suffix = checked.document.format === 'playcraft.score' ? '\nexport { renderSoundDocument, createStandaloneSoundPlayer };\n'
+        : '\nexport { renderAudioDocument, createStandaloneAudioPlayer };\n';
+    if (checked.source.rendererBuildHash !== engine.rendererBuildHash || Buffer.from(checked.files.get('runtime.mjs')).toString('utf8') !== engine.script + suffix)
+        throw audioError('audio_library_engine_unavailable', 409);
+}
+/** Verify against platform engine bytes before publishing any executable member. */
+export async function prepareAudioLibraryImport(root, target, asset, assertCurrent) {
+    const checked = inspectAsset(asset);
+    await trustedEngine(checked);
+    await assertCurrent();
+    const sourcePath = `${target}/${checked.source.entryPath}`;
+    await audioProjectPath(root, sourcePath);
+    const { representationSetHash: _previous, ...oldPayload } = checked.manifest;
+    const payload = { ...oldPayload, sourcePath }, representationSetHash = audioRepresentationSetHash(payload);
+    const manifest = Buffer.from(`${canonicalAudioJson({ ...payload, representationSetHash })}\n`);
+    const directory = `dist/audio/${digest(sourcePath)}/${checked.source.sourceContentHash}/${representationSetHash}`;
+    const members = new Map([...checked.files].map(([path, bytes]) => [path, Buffer.from(bytes)]));
+    members.set('manifest.json', manifest);
+    const destination = dirname(await audioProjectPath(root, `${directory}/manifest.json`));
+    await ensureSharedDirectory(root, dirname(destination));
+    const staging = `${destination}.${randomUUID()}.tmp`;
+    await ensureSharedDirectory(root, staging);
+    try {
+        for (const [path, bytes] of members)
+            await writeSharedFile(root, join(staging, path), bytes);
+        await assertCurrent();
+        const existing = await lstat(destination).catch(error => { if (error.code === 'ENOENT')
+            return undefined; throw error; });
+        if (existing) {
+            if (!existing.isDirectory() || existing.isSymbolicLink() || (await readdir(destination)).sort().join(',') !== [...members.keys()].sort().join(','))
+                throw audioError('audio_representation_conflict');
+            for (const [path, bytes] of members)
+                if (digest(await readFile(await audioProjectPath(root, `${directory}/${path}`))) !== digest(bytes))
+                    throw audioError('audio_representation_conflict');
+        }
+        else {
+            await rename(staging, destination);
+            const parent = await open(dirname(destination), 'r');
+            try {
+                await parent.sync();
+            }
+            finally {
+                await parent.close();
+            }
+        }
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+    const origin = { assetId: asset.assetId, contentHash: asset.contentHash, libraryPath: asset.libraryPath,
+        sourcePath: checked.source.sourcePath, sourceContentHash: checked.source.sourceContentHash, representationSetHash: checked.source.representationSetHash };
+    const metadata = Buffer.from(`${canonicalAudioJson({ version: 1, sourcePath, sourceContentHash: checked.source.sourceContentHash,
+        primaryPath: `${directory}/${checked.source.entryPath}`, representationSetHash, origin })}\n`);
+    const files = [{ path: checked.source.entryPath, bytes: members.get(checked.source.entryPath), mimeType: 'application/json' },
+        { path: 'audio-library.json', bytes: metadata, mimeType: 'application/json' }].map(({ bytes, ...file }) => ({ ...file, content: bytes.toString('base64'), sha256: digest(bytes) }));
+    const portable = { ...asset, files,
+        contentHash: digest(JSON.stringify(files.map(file => [file.path, file.sha256]).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))) };
+    return { asset: portable, packagePaths: [...members.keys()].map(path => `${directory}/${path}`) };
+}
+/** Recover verified import ancestry; reuse its audition only while the current source still matches. */
+export async function readImportedAudioLibrarySource(root, sourcePath, contentHash) {
+    const directory = dirname(sourcePath), sidecar = await audioProjectPath(root, `${directory === '.' ? '' : directory + '/'}audio-library.json`);
+    const stat = await lstat(sidecar).catch(error => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (!stat)
+        return undefined;
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 65_536)
+        throw audioError('audio_library_dependency_invalid', 409);
+    const metadata = JSON.parse(await readFile(sidecar, 'utf8'));
+    if (metadata.sourcePath !== sourcePath)
+        return undefined;
+    if (metadata.version !== 1 || typeof metadata.primaryPath !== 'string')
+        throw audioError('audio_library_dependency_invalid', 409);
+    try {
+        const packaged = await readAudioArtifactPackage(root, metadata.primaryPath);
+        const files = [...packaged.files].map(([path, bytes]) => ({ path: path.slice(path.lastIndexOf('/') + 1), content: bytes.toString('base64'), sha256: digest(bytes),
+            mimeType: path.endsWith('.mjs') ? 'text/javascript' : path.endsWith('.wav') ? 'audio/wav' : 'application/json' }));
+        const asset = { assetId: 'verified-local', name: 'sound', libraryPath: '', visibility: 'team', kind: 'bundle', contentHash: ''.padStart(64, '0'), files };
+        const checked = inspectAsset(asset, false);
+        await trustedEngine(checked);
+        if (checked.source.sourcePath !== sourcePath || checked.source.sourceContentHash !== metadata.sourceContentHash || checked.source.representationSetHash !== metadata.representationSetHash)
+            throw new Error();
+        const origin = audioLibraryOriginSchema.parse(metadata.origin), { representationSetHash: _relocated, ...payload } = checked.manifest;
+        if (origin.sourceContentHash !== checked.source.sourceContentHash
+            || audioRepresentationSetHash({ ...payload, sourcePath: origin.sourcePath }) !== origin.representationSetHash)
+            throw new Error();
+        const wav = Buffer.from(checked.files.get('audition.wav')), frames = (wav.length - 44) / 2;
+        let peak = 0, sum = 0;
+        for (let frame = 0; frame < frames; frame++) {
+            const value = wav.readInt16LE(44 + frame * 2) / 32768;
+            peak = Math.max(peak, Math.abs(value));
+            sum += value * value;
+        }
+        if (peak > .9801)
+            throw new Error();
+        const current = { wav, audition: { mimeType: 'audio/wav', size: wav.length, contentHash: digest(wav), pcmContentHash: checked.manifest.pcmContentHash,
+                rendererBuildHash: checked.source.rendererBuildHash, chromiumVersion: checked.manifest.chromiumVersion, renderKey: checked.manifest.renderKey,
+                metrics: { peak, rms: Math.sqrt(sum / frames), frames, sampleRate: 44100, channels: 1, silent: peak === 0 } },
+            representation: { sourceContentHash: checked.source.sourceContentHash, rendererBuildHash: checked.source.rendererBuildHash, representationSetHash: checked.source.representationSetHash,
+                modulePath: `${dirname(metadata.primaryPath)}/sound.mjs`, manifestPath: `${dirname(metadata.primaryPath)}/manifest.json`,
+                files: [...packaged.files].map(([path, bytes]) => ({ path, size: bytes.length, contentHash: digest(bytes) })) } };
+        return { origin, current: checked.source.sourceContentHash === contentHash ? current : undefined };
+    }
+    catch (error) {
+        throw audioError(error?.message === 'audio_library_engine_unavailable' ? 'audio_library_engine_unavailable' : 'audio_library_dependency_invalid', 409);
+    }
+}

package/dist/workspace-runtime/workspaces/audio-assets/library-package.js

@@ -0,0 +1,26 @@
+import { canonicalAudioJson, audioRepresentationSetHash, audioLibraryModule, inspectAudioLibrarySnapshot } from '@playcraft/common/cloud-workspace/runtime';
+import { audioRendererScript } from './renderer.js';
+import { audioError, digest } from './storage.js';
+/** Package a verified audition and its fixed engine; saving to the library does not adopt the candidate. */
+export async function createAudioLibrarySnapshot(input) {
+    const score = input.document.format === 'playcraft.score', engine = await audioRendererScript(score ? 'score' : 'synth-sfx');
+    if (engine.rendererBuildHash !== input.audition.rendererBuildHash)
+        throw audioError('engine_build_mismatch', 503);
+    const runtime = engine.script + (score ? '\nexport { renderSoundDocument, createStandaloneSoundPlayer };\n'
+        : '\nexport { renderAudioDocument, createStandaloneAudioPlayer };\n');
+    const members = [
+        { path: score ? 'sound.pcscore.json' : 'sound.pcaudio.json', mimeType: 'application/json', role: 'editable', bytes: Buffer.from(input.sourceText) },
+        { path: 'audition.wav', mimeType: 'audio/wav', role: 'audition', bytes: Buffer.from(input.wav) },
+        { path: 'runtime.mjs', mimeType: 'text/javascript', role: 'runtime', bytes: Buffer.from(runtime) },
+        { path: 'sound.mjs', mimeType: 'text/javascript', role: 'delivery', bytes: Buffer.from(audioLibraryModule(input.document, input.contentHash, engine.rendererBuildHash)) },
+    ];
+    const files = members.map(({ bytes, ...file }) => ({ ...file, size: bytes.length, contentHash: digest(bytes) }));
+    const payload = { version: 1, sourcePath: input.sourcePath, sourceContentHash: input.contentHash, sourceRenderHash: input.sourceRenderHash,
+        engine: input.document.engine, rendererBuildHash: engine.rendererBuildHash, chromiumVersion: input.audition.chromiumVersion,
+        renderKey: input.audition.renderKey, pcmContentHash: input.audition.pcmContentHash, files };
+    const manifest = Buffer.from(`${canonicalAudioJson({ ...payload, representationSetHash: audioRepresentationSetHash(payload) })}\n`);
+    const snapshot = { version: 1, target: input.target, revision: input.revision, sourcePath: input.sourcePath,
+        files: [...members.map(({ bytes, role: _role, ...file }) => ({ ...file, size: bytes.length, contentHash: digest(bytes), content: bytes.toString('base64') })),
+            { path: 'manifest.json', mimeType: 'application/json', size: manifest.length, contentHash: digest(manifest), content: manifest.toString('base64') }] };
+    return inspectAudioLibrarySnapshot(snapshot).snapshot;
+}

package/dist/workspace-runtime/workspaces/audio-assets/program-artifact-audit.js

@@ -0,0 +1,90 @@
+import { inflateRawSync } from 'node:zlib';
+import { extname } from 'node:path';
+import { audioError } from './storage.js';
+const MAX_BYTES = 64 * 1024 * 1024, MAX_ENTRIES = 4096;
+const MARKERS = { runtime: 'playcraft.audio-program.runtime.v1', prerender: 'playcraft.audio-program.prerender.v1' };
+const invalid = () => audioError('audio_program_artifact_unverified', 422);
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let i = 0; i < 8; i++)
+            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** Inspect archive members, never compressed binary substrings or evaluated project code. */
+function zipTextEntries(bytes) {
+    let end = -1;
+    for (let i = bytes.length - 22, minimum = Math.max(0, bytes.length - 65557); i >= minimum; i--)
+        if (bytes.readUInt32LE(i) === 0x06054b50 && i + 22 + bytes.readUInt16LE(i + 20) === bytes.length) {
+            end = i;
+            break;
+        }
+    if (end < 0 || bytes.readUInt16LE(end + 4) !== 0 || bytes.readUInt16LE(end + 6) !== 0)
+        throw invalid();
+    const count = bytes.readUInt16LE(end + 10), length = bytes.readUInt32LE(end + 12), offset = bytes.readUInt32LE(end + 16);
+    if (count > MAX_ENTRIES || count !== bytes.readUInt16LE(end + 8) || offset + length !== end)
+        throw invalid();
+    const entries = [];
+    let cursor = offset, inflated = 0;
+    for (let i = 0; i < count; i++) {
+        if (cursor + 46 > end || bytes.readUInt32LE(cursor) !== 0x02014b50)
+            throw invalid();
+        const flags = bytes.readUInt16LE(cursor + 8), method = bytes.readUInt16LE(cursor + 10), checksum = bytes.readUInt32LE(cursor + 16);
+        const packed = bytes.readUInt32LE(cursor + 20), size = bytes.readUInt32LE(cursor + 24), nameLength = bytes.readUInt16LE(cursor + 28);
+        const next = cursor + 46 + nameLength + bytes.readUInt16LE(cursor + 30) + bytes.readUInt16LE(cursor + 32), local = bytes.readUInt32LE(cursor + 42);
+        if (next > end || flags & 1 || ![0, 8].includes(method) || size > MAX_BYTES || local + 30 > offset || bytes.readUInt16LE(cursor + 34))
+            throw invalid();
+        const nameBytes = bytes.subarray(cursor + 46, cursor + 46 + nameLength), name = new TextDecoder('utf-8', { fatal: true }).decode(nameBytes);
+        if (!name || name.includes('\\') || name.startsWith('/') || name.split('/').includes('..') || name.includes('\0'))
+            throw invalid();
+        if (bytes.readUInt32LE(local) !== 0x04034b50 || bytes.readUInt16LE(local + 8) !== method || bytes.readUInt16LE(local + 6) !== flags)
+            throw invalid();
+        const localNameLength = bytes.readUInt16LE(local + 26), start = local + 30 + localNameLength + bytes.readUInt16LE(local + 28);
+        if (!bytes.subarray(local + 30, local + 30 + localNameLength).equals(nameBytes) || start + packed > offset)
+            throw invalid();
+        if (/\.(?:[cm]?js|html?)$/i.test(name)) {
+            if ((inflated += size) > MAX_BYTES)
+                throw invalid();
+            const data = bytes.subarray(start, start + packed), value = method === 0 ? data : inflateRawSync(data, { maxOutputLength: Math.max(1, size) });
+            if (value.length !== size || crc32(value) !== checksum)
+                throw invalid();
+            entries.push({ name, bytes: value });
+        }
+        cursor = next;
+    }
+    if (cursor !== end || !entries.length)
+        throw invalid();
+    return entries;
+}
+export function auditAudioProgramArtifact(bytes, outputPath, variant) {
+    if (!bytes.length || bytes.length > MAX_BYTES || !['runtime', 'prerender'].includes(variant))
+        throw invalid();
+    const extension = extname(outputPath).toLowerCase(), format = extension === '.zip' ? 'zip' : extension === '.html' || extension === '.htm' ? 'html' : undefined;
+    if (!format)
+        throw invalid();
+    const entries = format === 'zip' ? zipTextEntries(bytes) : [{ name: outputPath, bytes }];
+    const result = { format, inspectedFiles: entries.length, inspectedBytes: 0, expectedMarkerCount: 0, forbiddenMarkerCount: 0, coverage: 'html-javascript-and-explicit-base64-data' };
+    const seen = new Set();
+    const inspect = (data, depth) => {
+        if ((result.inspectedBytes += data.length) > MAX_BYTES)
+            throw invalid();
+        const text = new TextDecoder('utf-8', { fatal: true }).decode(data);
+        result.expectedMarkerCount += text.split(MARKERS[variant]).length - 1;
+        result.forbiddenMarkerCount += text.split(MARKERS[variant === 'runtime' ? 'prerender' : 'runtime']).length - 1;
+        for (const match of text.matchAll(/data:(?:text\/(?:javascript|html)|application\/(?:javascript|json));base64,([A-Za-z0-9+/]+={0,2})/g)) {
+            if (depth >= 3 || match[1].length > MAX_BYTES * 4 / 3)
+                throw invalid();
+            if (seen.has(match[1]))
+                continue;
+            seen.add(match[1]);
+            inspect(Buffer.from(match[1], 'base64'), depth + 1);
+        }
+    };
+    for (const entry of entries)
+        inspect(entry.bytes, 0);
+    if (result.forbiddenMarkerCount || !result.expectedMarkerCount)
+        throw Object.assign(invalid(), { details: { variant, ...result } });
+    return result;
+}

package/dist/workspace-runtime/workspaces/audio-assets/program-browser.js

@@ -0,0 +1,194 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { chmod, mkdtemp, open, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { chromium } from 'playwright-core';
+import { AUDIO_DYNAMIC_LIMITS, parseAudioDynamicProgram, serializeAudioDynamicProgram, validateAudioDynamicProgram, } from '@playcraft/common/cloud-workspace/runtime';
+import { audioProgramRendererScript } from './program-engine.js';
+import { AUDIO_RENDER_CHUNK_BYTES, encodeAudioRenderChunk, writeAudioRenderOutput } from './render-worker.js';
+const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+function inputSnapshot(program, files, stateId) {
+    const checked = parseAudioDynamicProgram(serializeAudioDynamicProgram(validateAudioDynamicProgram(program)));
+    const state = checked.states.find(item => item.id === stateId);
+    if (!state)
+        throw new Error('invalid_audio_state');
+    if (!files || ![Object.prototype, null].includes(Object.getPrototypeOf(files)))
+        throw new Error('audio_dependency_mismatch');
+    const dependencies = checked.assets.flatMap(asset => asset.kind === 'synth' ? [asset.source, asset.manifest] : [asset.file]);
+    if (dependencies.reduce((sum, ref) => sum + ref.size, 0) > AUDIO_DYNAMIC_LIMITS.inputBytes)
+        throw new Error('audio_program_budget_exceeded');
+    const encoded = Object.create(null);
+    let total = 0;
+    for (const [path, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(files))) {
+        if (!('value' in descriptor) || !(descriptor.value instanceof Uint8Array))
+            throw new Error('audio_dependency_mismatch');
+        total += descriptor.value.byteLength;
+        if (total > AUDIO_DYNAMIC_LIMITS.inputBytes)
+            throw new Error('audio_program_budget_exceeded');
+        const bytes = Buffer.from(descriptor.value), references = dependencies.filter(ref => ref.path === path);
+        if (!references.length || references.some(ref => bytes.length !== ref.size || digest(bytes) !== ref.contentHash))
+            throw new Error('audio_dependency_mismatch');
+        encoded[path] = bytes.toString('base64');
+    }
+    if (dependencies.some(ref => !Object.hasOwn(encoded, ref.path)))
+        throw new Error('audio_dependency_missing');
+    return { program: checked, files: encoded, stateId, frames: Math.ceil(state.durationSeconds * 44100) };
+}
+function checkedMetrics(value, frames) {
+    if (!value || value.frames !== frames || value.channels !== 1 || value.sampleRate !== 44100
+        || !Number.isFinite(value.peak) || value.peak < 0 || !Number.isFinite(value.rms) || value.rms < 0
+        || value.rms > value.peak + 1e-12 || typeof value.silent !== 'boolean' || value.silent !== (value.peak === 0))
+        throw new Error('invalid_audio_output');
+    if (value.peak > .98)
+        throw new Error('render_peak_exceeded');
+    return value;
+}
+async function verifyPcm(path, frames, expectedHash, assertActive) {
+    const hash = createHash('sha256');
+    let bytes = 0, peak = 0, energy = 0;
+    for await (const chunk of createReadStream(path, { highWaterMark: AUDIO_RENDER_CHUNK_BYTES })) {
+        assertActive();
+        bytes += chunk.length;
+        if (bytes > frames * 4 || chunk.length % 4)
+            throw new Error('invalid_audio_output');
+        hash.update(chunk);
+        for (let offset = 0; offset < chunk.length; offset += 4) {
+            const sample = chunk.readFloatLE(offset);
+            if (!Number.isFinite(sample))
+                throw new Error('invalid_audio_output');
+            peak = Math.max(peak, Math.abs(sample));
+            energy += sample * sample;
+        }
+    }
+    if (bytes !== frames * 4 || hash.digest('hex') !== expectedHash)
+        throw new Error('invalid_audio_output');
+    return checkedMetrics({ frames, channels: 1, sampleRate: 44100, peak, rms: Math.sqrt(energy / frames), silent: peak === 0 }, frames);
+}
+async function readWave(path, frames, assertActive) {
+    const file = await open(path, 'r');
+    try {
+        const size = 44 + frames * 2;
+        if ((await file.stat()).size !== size)
+            throw new Error('invalid_audio_output');
+        const bytes = Buffer.alloc(size);
+        for (let offset = 0; offset < size;) {
+            assertActive();
+            const { bytesRead } = await file.read(bytes, offset, Math.min(AUDIO_RENDER_CHUNK_BYTES, size - offset), offset);
+            if (!bytesRead)
+                throw new Error('invalid_audio_output');
+            offset += bytesRead;
+        }
+        if (bytes.toString('ascii', 0, 4) !== 'RIFF' || bytes.toString('ascii', 8, 12) !== 'WAVE'
+            || bytes.toString('ascii', 12, 16) !== 'fmt ' || bytes.toString('ascii', 36, 40) !== 'data'
+            || bytes.readUInt32LE(4) !== size - 8 || bytes.readUInt32LE(16) !== 16 || bytes.readUInt16LE(20) !== 1
+            || bytes.readUInt16LE(22) !== 1 || bytes.readUInt32LE(24) !== 44100 || bytes.readUInt32LE(28) !== 88200
+            || bytes.readUInt16LE(32) !== 2 || bytes.readUInt16LE(34) !== 16 || bytes.readUInt32LE(40) !== frames * 2)
+            throw new Error('invalid_audio_output');
+        return bytes;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The compile caller owns this process; only fixed platform code is executed by its owned browser. */
+export async function renderAudioProgramInBrowser(program, files, stateId, signal) {
+    const uid = process.getuid?.();
+    if (typeof uid !== 'number' || uid <= 0)
+        throw new Error('audio_renderer_identity_unavailable');
+    let cancelled = signal?.aborted === true, timedOut = false, browser, closing, scratch;
+    const assertActive = () => { if (timedOut)
+        throw new Error('audio_render_timeout'); if (cancelled || signal?.aborted)
+        throw new Error('audio_render_cancelled'); };
+    const closeOwnedBrowser = () => browser ? closing ??= browser.close() : Promise.resolve();
+    const cancel = () => { cancelled = true; void closeOwnedBrowser().catch(() => undefined); };
+    assertActive();
+    const snapshot = inputSnapshot(program, files, stateId);
+    signal?.addEventListener('abort', cancel, { once: true });
+    process.once('SIGTERM', cancel);
+    const deadline = setTimeout(() => { timedOut = true; cancel(); }, 60_000);
+    deadline.unref?.();
+    try {
+        assertActive();
+        const engine = await audioProgramRendererScript();
+        if (Buffer.byteLength(engine.script) > 512 * 1024 || !/^[a-f0-9]{64}$/.test(engine.rendererBuildHash)
+            || digest(engine.script) !== engine.rendererBuildHash)
+            throw new Error('engine_build_mismatch');
+        assertActive();
+        scratch = await mkdtemp(join(tmpdir(), 'playcraft-audio-program-'));
+        await chmod(scratch, 0o700);
+        const output = join(scratch, 'render');
+        browser = await chromium.launch({ executablePath: process.env.PLAYCRAFT_CHROMIUM_PATH || '/usr/bin/chromium',
+            headless: true, chromiumSandbox: true, timeout: 8000, handleSIGTERM: false, handleSIGINT: false, handleSIGHUP: false,
+            args: ['--mute-audio', '--disable-background-networking'] });
+        assertActive();
+        const chromiumVersion = browser.version();
+        const context = await browser.newContext({ serviceWorkers: 'block', acceptDownloads: false });
+        await context.route('**/*', route => route.abort('blockedbyclient'));
+        const page = await context.newPage();
+        await page.addScriptTag({ content: engine.script });
+        assertActive();
+        const rendered = await page.evaluateHandle(async ({ program, files, stateId, frames }) => {
+            const engine = globalThis.playcraftAudioProgram;
+            const decoded = Object.create(null);
+            let size = 0;
+            for (const [path, value] of Object.entries(files)) {
+                const text = atob(value);
+                size += text.length;
+                if (size > 2 * 1024 * 1024)
+                    throw new Error('audio_program_budget_exceeded');
+                const bytes = new Uint8Array(text.length);
+                for (let index = 0; index < text.length; index++)
+                    bytes[index] = text.charCodeAt(index);
+                decoded[path] = bytes;
+            }
+            const buffer = await engine.renderAudioDynamicProgram(program, decoded, stateId);
+            if (buffer.length !== frames || buffer.length > 2_646_000 || buffer.numberOfChannels !== 1 || buffer.sampleRate !== 44100)
+                throw new Error('invalid_audio_output');
+            const metrics = engine.soundPcmMetrics(buffer);
+            if (metrics.peak > .98)
+                throw new Error('render_peak_exceeded');
+            return { buffer, wav: engine.soundBufferToWav(buffer), metrics };
+        }, snapshot);
+        let summary;
+        try {
+            summary = await rendered.evaluate(value => ({ frames: value.buffer.length, wavBytes: value.wav.byteLength, metrics: value.metrics }));
+            checkedMetrics(summary.metrics, snapshot.frames);
+            assertActive();
+            await writeAudioRenderOutput(output, summary, chromiumVersion, request => {
+                assertActive();
+                return rendered.evaluate(encodeAudioRenderChunk, request);
+            }, snapshot.frames);
+        }
+        finally {
+            await rendered.dispose();
+        }
+        await closeOwnedBrowser();
+        assertActive();
+        const meta = JSON.parse(await readFile(`${output}.json`, 'utf8'));
+        if (!/^[a-f0-9]{64}$/.test(meta.pcmContentHash))
+            throw new Error('invalid_audio_output');
+        const metrics = await verifyPcm(`${output}.pcm`, snapshot.frames, meta.pcmContentHash, assertActive);
+        if (metrics.peak !== summary.metrics.peak || Math.abs(metrics.rms - summary.metrics.rms) > 1e-12)
+            throw new Error('invalid_audio_output');
+        const wav = await readWave(`${output}.wav`, snapshot.frames, assertActive);
+        assertActive();
+        return { wav, pcmContentHash: meta.pcmContentHash, chromiumVersion, metrics, rendererBuildHash: engine.rendererBuildHash };
+    }
+    catch (error) {
+        assertActive();
+        throw error;
+    }
+    finally {
+        try {
+            await closeOwnedBrowser();
+        }
+        finally {
+            signal?.removeEventListener('abort', cancel);
+            process.removeListener('SIGTERM', cancel);
+            clearTimeout(deadline);
+            if (scratch)
+                await rm(scratch, { recursive: true, force: true });
+        }
+    }
+}

package/dist/workspace-runtime/workspaces/audio-assets/program-build-inputs.js

@@ -0,0 +1,122 @@
+import { constants } from 'node:fs';
+import { lstat, open, opendir, realpath } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, sep } from 'node:path';
+import { canonicalAudioJson } from '@playcraft/common/cloud-workspace/runtime';
+import { readAudioProgramPackage } from './program-package.js';
+import { audioError, audioProjectPath, digest } from './storage.js';
+import { ensureSharedDirectory, writeSharedFile } from '../shared-write.js';
+export const AUDIO_PROGRAM_BUILD_PROTOCOL = 1;
+const HASH = /^[a-f0-9]{64}$/;
+const MAX_PACKAGES = 256, MAX_ENTRIES = 8192, MAX_BYTES = 64 * 1024 * 1024;
+/** A caller must provide an already-created build clone, never a source alias or ancestor. */
+export async function assertAudioProgramBuildClone(sourceRoot, cloneRoot) {
+    const [source, clone, stat] = await Promise.all([realpath(sourceRoot), realpath(cloneRoot), lstat(cloneRoot)]);
+    const rel = relative(source, clone), ancestor = relative(clone, source);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || !rel || !ancestor || !ancestor.startsWith(`..${sep}`) && ancestor !== '..' && !isAbsolute(ancestor)
+        || !rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel) && !rel.startsWith(`.playcraft-delivery${sep}`))
+        throw audioError('invalid_audio_build_clone', 400);
+}
+async function manifests(root) {
+    const found = [];
+    let entries = 0;
+    const visit = async (path, depth) => {
+        const absolute = await audioProjectPath(root, path);
+        const stat = await lstat(absolute).catch(error => { if (error.code === 'ENOENT')
+            return undefined; throw error; });
+        if (!stat)
+            return;
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw audioError('invalid_audio_path', 400);
+        const directory = await opendir(absolute, { bufferSize: 32 });
+        for await (const entry of directory) {
+            if (++entries > MAX_ENTRIES)
+                throw audioError('audio_build_budget_exceeded', 422);
+            if (depth === 3) {
+                if (entry.name === 'manifest.json') {
+                    if (!entry.isFile() || entry.isSymbolicLink())
+                        throw audioError('audio_program_package_invalid', 422);
+                    if (found.length >= MAX_PACKAGES)
+                        throw audioError('audio_build_budget_exceeded', 422);
+                    found.push(`${path}/manifest.json`);
+                }
+            }
+            else if (HASH.test(entry.name)) {
+                if (!entry.isDirectory() || entry.isSymbolicLink())
+                    throw audioError('audio_program_package_invalid', 422);
+                await visit(`${path}/${entry.name}`, depth + 1);
+            }
+        }
+    };
+    await visit('dist/audio/programs', 0);
+    return found.sort();
+}
+async function currentSource(root, path) {
+    const absolute = await audioProjectPath(root, path);
+    const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
+        .catch(error => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (!handle)
+        return undefined;
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || before.nlink !== 1 || before.size > 65536)
+            throw audioError('invalid_audio_program', 400);
+        const bytes = await handle.readFile(), after = await handle.stat();
+        if (bytes.length !== before.size || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+            throw audioError('audio_build_input_changed');
+        return bytes;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** The authoritative reader verifies the complete program package before any ignored output joins a clone. */
+export async function readAudioProgramBuildInputs(root, destination) {
+    if (destination)
+        await assertAudioProgramBuildClone(root, destination);
+    const packages = [], copied = new Map();
+    let total = 0;
+    const capture = async (path, bytes) => {
+        const contentHash = digest(bytes), old = copied.get(path);
+        if (old && (old.contentHash !== contentHash || old.size !== bytes.length))
+            throw audioError('audio_build_input_changed');
+        if (!old) {
+            if ((total += bytes.length) > MAX_BYTES)
+                throw audioError('audio_build_budget_exceeded', 422);
+            copied.set(path, { contentHash, size: bytes.length });
+            if (destination) {
+                const target = await audioProjectPath(destination, path, true);
+                await ensureSharedDirectory(destination, dirname(target));
+                await writeSharedFile(destination, target, bytes);
+            }
+        }
+        return { path, contentHash, size: bytes.length };
+    };
+    for (const manifestPath of await manifests(root)) {
+        let bundle;
+        try {
+            bundle = await readAudioProgramPackage(root, manifestPath);
+        }
+        catch (error) {
+            throw Object.assign(audioError('audio_program_package_invalid', 422), { details: { manifestPath,
+                    reason: typeof error?.code === 'string' ? error.code : 'validation_failed' } });
+        }
+        const source = await currentSource(root, bundle.sourcePath), files = [];
+        for (const [path, bytes] of [...bundle.files].sort(([a], [b]) => a.localeCompare(b)))
+            files.push(await capture(path, bytes));
+        if (source !== undefined)
+            await capture(bundle.sourcePath, source);
+        packages.push({ manifestPath, sourcePath: bundle.sourcePath, sourceContentHash: bundle.sourceContentHash,
+            currentSourceContentHash: source === undefined ? null : digest(source), semanticHash: bundle.semanticHash,
+            runtimeModulePath: bundle.runtimeModulePath, prerenderModulePath: bundle.prerenderModulePath, files });
+    }
+    return { version: 1, inputHash: digest(canonicalAudioJson(packages)), packages };
+}
+export async function verifyAudioProgramBuildInputs(root, snapshot) {
+    if (snapshot.version !== 1 || digest(canonicalAudioJson(snapshot.packages)) !== snapshot.inputHash
+        || (await readAudioProgramBuildInputs(root)).inputHash !== snapshot.inputHash)
+        throw audioError('audio_build_input_changed');
+}
+export function markAudioProgramBuildInputs(bytes, snapshot) {
+    return snapshot.packages.length ? Buffer.concat([Buffer.from(`<!--playcraft-audio-program-inputs:v1:${snapshot.inputHash}-->\n`), bytes]) : bytes;
+}

package/dist/workspace-runtime/workspaces/audio-assets/program-engine.js

@@ -0,0 +1,39 @@
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { assertUniqueJsonKeys, audioSha256, AudioRenderError } from '@playcraft/common/cloud-workspace/runtime';
+import { audioRendererScript } from './renderer.js';
+import { audioError, digest } from './storage.js';
+const strip = (text) => text.replace(/^export\s+(?=(?:async\s+)?function\b|const\b|class\b|let\b)/gm, '')
+    .replace(/^\/\/# sourceMappingURL=.*$/gm, '');
+async function body(name, permitted) {
+    const entry = createRequire(import.meta.url).resolve('@playcraft/common/cloud-workspace/runtime');
+    const source = await readFile(join(dirname(entry), name), 'utf8');
+    const pattern = /^import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"];?\s*$/gm;
+    if ([...source.matchAll(pattern)].some(match => !permitted.includes(match[1])))
+        throw audioError('engine_unavailable', 503);
+    const result = source.replace(pattern, '');
+    if (/^import\s|\bfrom\s+['"]/m.test(result))
+        throw audioError('engine_unavailable', 503);
+    return strip(result);
+}
+/** Only bundled platform code is executable; project dependencies remain validated bytes. */
+export async function audioProgramRendererScript() {
+    const score = await audioRendererScript('score');
+    const document = await body('audio-dynamic-document.js', ['./audio-document.js', './audio-synthesizer.js']);
+    const hybrid = await body('audio-hybrid-player.js', ['./audio-document.js', './audio-synthesizer.js', './score-synthesizer.js', './audio-dynamic-document.js']);
+    const script = `${score.script}\n${audioSha256.toString()}\n${assertUniqueJsonKeys.toString()}\n${document}\n${hybrid}\n` +
+        'globalThis.playcraftAudioProgram={renderAudioDynamicProgram,soundBufferToWav,soundPcmMetrics};';
+    return { script, rendererBuildHash: digest(script) };
+}
+export async function audioProgramGameRuntime() {
+    const { script, rendererBuildHash } = await audioProgramRendererScript();
+    const code = script.replace(/^globalThis\.playcraftAudio(?:Program)?\s*=.*;?$/gm, '') +
+        '\nexport {createAudioHybridPlayer,createStandaloneAudioPlayer,createStandaloneSoundPlayer};\n';
+    return { code, contentHash: digest(code), rendererBuildHash };
+}
+export async function audioProgramPrerenderRuntime() {
+    const player = await body('audio-prerender-player.js', ['./audio-document.js', './audio-synthesizer.js']);
+    const code = `${AudioRenderError.toString()}\n${audioSha256.toString()}\n${player}\nexport {createAudioPrerenderProgramPlayer};\n`;
+    return { code, contentHash: digest(code) };
+}