@playcraft/cli 0.1.66 → 0.1.68

package/dist/workspace-runtime/workspaces/audio-assets/render-worker.js

@@ -0,0 +1,117 @@
+import { open, readFile, rm } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+import { chromium } from 'playwright-core';
+export const AUDIO_RENDER_CHUNK_BYTES = 64 * 1024;
+/** This function is serialized into the isolated browser and must have no module closure. */
+export function encodeAudioRenderChunk(rendered, request) {
+    const { kind, offset, length } = request;
+    if (!['pcm', 'wav'].includes(kind) || !Number.isSafeInteger(offset) || offset < 0
+        || !Number.isSafeInteger(length) || length < 1 || length > 64 * 1024)
+        throw new Error('audio_budget_exceeded');
+    const total = kind === 'pcm' ? rendered.buffer.length * 4 : rendered.wav.byteLength;
+    if (offset + length > total || kind === 'pcm' && (offset % 4 || length % 4))
+        throw new Error('invalid_audio_output');
+    let data;
+    if (kind === 'pcm') {
+        data = new Uint8Array(length);
+        const view = new DataView(data.buffer), samples = rendered.buffer.getChannelData(0);
+        for (let index = 0; index < length / 4; index++)
+            view.setFloat32(index * 4, samples[offset / 4 + index], true);
+    }
+    else
+        data = new Uint8Array(rendered.wav, offset, length);
+    let text = '';
+    for (let index = 0; index < data.length; index += 16384)
+        text += String.fromCharCode(...data.subarray(index, index + 16384));
+    return btoa(text);
+}
+/** Acknowledged, bounded chunks keep the control transport and worker from retaining the entire payload. */
+export async function writeAudioRenderOutput(outputPath, summary, chromiumVersion, readChunk, maximumFrames) {
+    if (!Number.isSafeInteger(summary.frames) || summary.frames < 1 || summary.frames > maximumFrames
+        || maximumFrames > 2_646_000 || summary.wavBytes !== 44 + summary.frames * 2)
+        throw new Error('audio_budget_exceeded');
+    const created = [], files = [];
+    const openOutput = async (suffix) => {
+        // shared: the render worker runs as the development identity and the controller reads its bytes.
+        const path = `${outputPath}.${suffix}`, file = await open(path, 'wx', 0o660);
+        created.push(path);
+        files.push(file);
+        return file;
+    };
+    try {
+        const pcmHash = createHash('sha256');
+        for (const kind of ['pcm', 'wav']) {
+            const file = await openOutput(kind), total = kind === 'pcm' ? summary.frames * 4 : summary.wavBytes;
+            for (let offset = 0; offset < total; offset += AUDIO_RENDER_CHUNK_BYTES) {
+                const length = Math.min(AUDIO_RENDER_CHUNK_BYTES, total - offset);
+                const encoded = await readChunk({ kind, offset, length });
+                if (typeof encoded !== 'string' || encoded.length !== Math.ceil(length / 3) * 4
+                    || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded))
+                    throw new Error('invalid_audio_output');
+                const chunk = Buffer.from(encoded, 'base64');
+                if (chunk.length !== length || chunk.toString('base64') !== encoded)
+                    throw new Error('invalid_audio_output');
+                await file.writeFile(chunk);
+                if (kind === 'pcm')
+                    pcmHash.update(chunk);
+            }
+        }
+        const metadata = await openOutput('json');
+        await metadata.writeFile(JSON.stringify({ chromiumVersion, metrics: summary.metrics, pcmContentHash: pcmHash.digest('hex') }));
+        for (const file of files)
+            await file.close();
+        return created;
+    }
+    catch (error) {
+        await Promise.allSettled(files.map(file => file.close()));
+        await Promise.all(created.map(path => rm(path, { force: true })));
+        throw error;
+    }
+}
+/** This worker executes only the verified platform graph, never a project page. */
+async function main() {
+    const [inputPath, outputPath] = process.argv.slice(2);
+    const uid = process.getuid?.();
+    if (!inputPath || !outputPath || typeof uid !== 'number' || uid <= 0)
+        throw new Error('audio_renderer_identity_unavailable');
+    const input = JSON.parse(await readFile(inputPath, 'utf8'));
+    if (Buffer.byteLength(input.script) > 512 * 1024 || createHash('sha256').update(input.script).digest('hex') !== input.rendererBuildHash)
+        throw new Error('engine_build_mismatch');
+    const browser = await chromium.launch({ executablePath: process.env.PLAYCRAFT_CHROMIUM_PATH || '/usr/bin/chromium',
+        headless: true, chromiumSandbox: true, timeout: 8000, args: ['--mute-audio', '--disable-background-networking'] });
+    let created = [];
+    try {
+        try {
+            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: input.script });
+            const rendered = await page.evaluateHandle(async (document) => {
+                const engine = globalThis.playcraftAudio;
+                const buffer = await engine.renderAudioDocument(document);
+                const maximumFrames = document && typeof document === 'object' && 'format' in document && document.format === 'playcraft.score' ? 2_646_000 : 441_000;
+                if (buffer.length > maximumFrames || buffer.numberOfChannels !== 1)
+                    throw new Error('audio_budget_exceeded');
+                return { buffer, wav: engine.audioBufferToWav(buffer), metrics: engine.audioPcmMetrics(buffer) };
+            }, input.document);
+            try {
+                const summary = await rendered.evaluate(value => ({ frames: value.buffer.length, wavBytes: value.wav.byteLength, metrics: value.metrics }));
+                const score = input.document && typeof input.document === 'object' && 'format' in input.document && input.document.format === 'playcraft.score';
+                created = await writeAudioRenderOutput(outputPath, summary, browser.version(), request => rendered.evaluate(encodeAudioRenderChunk, request), score ? 2_646_000 : 441_000);
+            }
+            finally {
+                await rendered.dispose();
+            }
+        }
+        finally {
+            await browser.close();
+        }
+    }
+    catch (error) {
+        await Promise.all(created.map(path => rm(path, { force: true })));
+        throw error;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
+    void main().catch(error => { process.stderr.write(`${error instanceof Error ? error.message : 'audio_render_failed'}\n`); process.exitCode = 1; });

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

@@ -0,0 +1,128 @@
+import { createRequire } from 'node:module';
+import { createReadStream } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { soundDurationSeconds } from '@playcraft/common/cloud-workspace/runtime';
+import { runDeveloperCommand } from '../developer-command.js';
+import { openScratchToDevelopment } from '../directory-access.js';
+import { workspaceGroup, writeSharedFile } from '../shared-write.js';
+import { audioError, digest } from './storage.js';
+import { stopLauncherExecution } from '../../codex/launcher-client.js';
+import { launcherSocket } from '../developer-command.js';
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const queues = new WeakMap();
+export async function verifyAudioRenderPcm(path, expectedBytes, expectedHash) {
+    const hash = createHash('sha256');
+    let bytes = 0;
+    for await (const chunk of createReadStream(path, { highWaterMark: 64 * 1024 })) {
+        bytes += chunk.length;
+        if (bytes > expectedBytes)
+            throw audioError('audio_render_failed', 422);
+        hash.update(chunk);
+    }
+    if (bytes !== expectedBytes || hash.digest('hex') !== expectedHash)
+        throw audioError('audio_render_failed', 422);
+}
+export async function recoverAudioRenderers(state, scope) {
+    for (const writer of state.journal.listManagedWrites(scope)) {
+        if (writer.stoppedAt || !writer.writeId.startsWith('audio:'))
+            continue;
+        if (writer.executionMode === 'launcher' && writer.launcher && writer.launcher.processId === writer.writeId &&
+            writer.launcher.runtimeEpoch === writer.runtimeEpoch && launcherSocket(state)) {
+            try {
+                await stopLauncherExecution(launcherSocket(state), writer.launcher);
+            }
+            catch {
+                throw audioError('audio_render_process_unknown', 503);
+            }
+        }
+        else {
+            const absent = (pid) => { try {
+                process.kill(pid, 0);
+                return false;
+            }
+            catch (error) {
+                return error.code === 'ESRCH';
+            } };
+            if (!writer.pid || !absent(writer.pid) || !absent(-writer.pid))
+                throw audioError('audio_render_process_unknown', 503);
+        }
+        await state.journal.putManagedWrite({ ...writer, stoppedAt: new Date().toISOString() });
+    }
+}
+export async function audioRendererScript(kind = 'synth-sfx') {
+    const require = createRequire(import.meta.url);
+    const entry = require.resolve('@playcraft/common/cloud-workspace/runtime');
+    const source = await readFile(join(dirname(entry), 'audio-synthesizer.js'), 'utf8');
+    if (/^import\s/m.test(source) || /\bfrom\s+['"]/m.test(source))
+        throw audioError('engine_unavailable', 503);
+    const strip = (value) => value.replace(/^export\s+(?=(?:async\s+)?function\b|const\b|class\b|let\b)/gm, '').replace(/^\/\/# sourceMappingURL=.*$/gm, '');
+    let script = `${strip(source)}\n` + 'globalThis.playcraftAudio={renderAudioDocument,audioBufferToWav,audioPcmMetrics};';
+    if (kind === 'score') {
+        const score = await readFile(join(dirname(entry), 'score-synthesizer.js'), 'utf8');
+        // Only the fixed platform synthesizer may be concatenated; schema/runtime dependencies are not executable project input.
+        const imports = [...score.matchAll(/^import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"];?$/gm)];
+        if (imports.some(match => match[2] !== './audio-synthesizer.js'))
+            throw audioError('engine_unavailable', 503);
+        const body = score.replace(/^import\s+[\s\S]*?\s+from\s+['"][^'"]+['"];?\s*$/gm, '');
+        if (/^import\s/m.test(body) || /\bfrom\s+['"]/m.test(body))
+            throw audioError('engine_unavailable', 503);
+        script = `${strip(source)}\n${strip(body)}\nglobalThis.playcraftAudio={renderAudioDocument:renderSoundDocument,audioBufferToWav:soundBufferToWav,audioPcmMetrics:soundPcmMetrics};`;
+    }
+    return { script, rendererBuildHash: digest(script) };
+}
+export function workspaceAudioRenderer(state, projectRoot, scope = 'single:basic') {
+    const execute = async (document, signal) => {
+        await recoverAudioRenderers(state, scope);
+        const bundle = await audioRendererScript(document.format === 'playcraft.score' ? 'score' : 'synth-sfx');
+        const scratch = await mkdtemp(join(tmpdir(), 'playcraft-audio-render-'));
+        try {
+            await openScratchToDevelopment(scratch, await workspaceGroup(projectRoot));
+            const input = join(scratch, 'input.json'), output = join(scratch, 'result');
+            await writeSharedFile(projectRoot, input, JSON.stringify({ document, ...bundle }));
+            const worker = fileURLToPath(new URL('./render-worker.js', import.meta.url));
+            let log = '';
+            const writeId = `audio:${digest(input).slice(0, 24)}`;
+            let managed;
+            const result = await runDeveloperCommand(state, { processId: writeId, cwd: projectRoot,
+                command: `${quote(process.execPath)} ${quote(worker)} ${quote(input)} ${quote(output)}`, timeoutMs: document.format === 'playcraft.score' ? 60_000 : 20_000,
+                signal, onOutput: chunk => { log = (log + String(chunk)).slice(-4096); },
+                onStarted: async (identity) => {
+                    managed = { writeId, workspaceId: scope, source: 'background', startedAt: new Date().toISOString(), runtimeEpoch: state.runtimeEpoch,
+                        pid: identity.pid, executionMode: identity.launcher ? 'launcher' : 'local', launcher: identity.launcher };
+                    await state.journal.putManagedWrite(managed);
+                } });
+            if (managed && result.code !== undefined)
+                await state.journal.putManagedWrite({ ...managed, stoppedAt: new Date().toISOString() });
+            if (result.code !== 0 || result.timedOut || result.canceled) {
+                const code = result.canceled ? 'audio_render_cancelled' : /render_peak_exceeded/.test(log) ? 'render_peak_exceeded'
+                    : /identity|sandbox|browser|executable/i.test(log) ? 'engine_unavailable' : 'audio_render_failed';
+                throw audioError(code, code === 'engine_unavailable' ? 503 : 422);
+            }
+            const meta = JSON.parse(await readFile(`${output}.json`, 'utf8'));
+            const wav = await readFile(`${output}.wav`);
+            const frames = Math.ceil(soundDurationSeconds(document) * 44100);
+            await verifyAudioRenderPcm(`${output}.pcm`, frames * 4, meta.pcmContentHash);
+            if (wav.length !== 44 + frames * 2 || !Number.isFinite(meta.metrics?.peak))
+                throw audioError('audio_render_failed', 422);
+            return { wav, pcmContentHash: meta.pcmContentHash, rendererBuildHash: bundle.rendererBuildHash,
+                chromiumVersion: meta.chromiumVersion, metrics: meta.metrics };
+        }
+        finally {
+            await rm(scratch, { recursive: true, force: true });
+        }
+    };
+    return (document, signal) => {
+        let scopes = queues.get(state);
+        if (!scopes) {
+            scopes = new Map();
+            queues.set(state, scopes);
+        }
+        const next = (scopes.get(scope) ?? Promise.resolve()).catch(() => undefined).then(() => execute(document, signal));
+        scopes.set(scope, next);
+        return next;
+    };
+}

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

@@ -0,0 +1,73 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, open, readFile, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { canonicalAudioJson, audioRepresentationSetHash } from '@playcraft/common/cloud-workspace/runtime';
+import { audioRendererScript } from './renderer.js';
+import { audioProjectPath, audioError, digest } from './storage.js';
+import { ensureSharedDirectory, writeSharedFile } from '../shared-write.js';
+/** Every package member is immutable and verified before the source commit becomes visible. */
+export async function publishAudioRepresentations(root, sourcePath, source, wav) {
+    const score = source.document.format === 'playcraft.score';
+    const engine = await audioRendererScript(score ? 'score' : 'synth-sfx');
+    if (engine.rendererBuildHash !== source.audition.rendererBuildHash)
+        throw audioError('engine_build_mismatch', 503);
+    const player = score ? 'createStandaloneSoundPlayer' : 'createStandaloneAudioPlayer';
+    const runtime = `${engine.script}\nexport { ${score ? 'renderSoundDocument' : 'renderAudioDocument'}, ${player} };\n`;
+    const module = `import { ${player} } from './runtime.mjs';\n` +
+        `const document=${canonicalAudioJson(source.document)};\n` +
+        `export const sourceContentHash=${JSON.stringify(source.contentHash)};\nexport const sourceRenderHash=${JSON.stringify(source.sourceRenderHash)};\n` +
+        `export const rendererBuildHash=${JSON.stringify(engine.rendererBuildHash)};\n` +
+        `export function createSound(){return ${player}(document);}\n`;
+    const bytes = [
+        { path: score ? 'sound.pcscore.json' : 'sound.pcaudio.json', mimeType: 'application/json', role: 'editable', data: Buffer.from(source.sourceText) },
+        { path: 'audition.wav', mimeType: 'audio/wav', role: 'audition', data: Buffer.from(wav) },
+        { path: 'runtime.mjs', mimeType: 'text/javascript', role: 'runtime', data: Buffer.from(runtime) },
+        { path: 'sound.mjs', mimeType: 'text/javascript', role: 'delivery', data: Buffer.from(module) },
+    ];
+    if (digest(wav) !== source.audition.contentHash)
+        throw audioError('audio_audition_unavailable', 404);
+    const files = bytes.map(({ data, ...entry }) => ({ ...entry, contentHash: digest(data), size: data.length }));
+    const manifest = { version: 1, sourcePath, sourceContentHash: source.contentHash, sourceRenderHash: source.sourceRenderHash,
+        engine: source.document.engine, rendererBuildHash: engine.rendererBuildHash, chromiumVersion: source.audition.chromiumVersion,
+        renderKey: source.audition.renderKey, pcmContentHash: source.audition.pcmContentHash, files };
+    const representationSetHash = audioRepresentationSetHash(manifest);
+    const relative = `dist/audio/${digest(sourcePath)}/${source.contentHash}/${representationSetHash}`;
+    const destination = await audioProjectPath(root, `${relative}/manifest.json`);
+    const directory = dirname(destination), staging = `${directory}.${randomUUID()}.tmp`;
+    const manifestBytes = Buffer.from(`${canonicalAudioJson({ ...manifest, representationSetHash })}\n`);
+    await ensureSharedDirectory(root, dirname(directory));
+    await ensureSharedDirectory(root, staging);
+    try {
+        for (const entry of bytes)
+            await writeSharedFile(root, join(staging, entry.path), entry.data);
+        await writeSharedFile(root, join(staging, 'manifest.json'), manifestBytes);
+        const existing = await lstat(directory).catch(error => { if (error.code === 'ENOENT')
+            return undefined; throw error; });
+        if (existing) {
+            if (!existing.isDirectory() || existing.isSymbolicLink())
+                throw audioError('audio_representation_conflict');
+            for (const entry of [...bytes, { path: 'manifest.json', data: manifestBytes }]) {
+                const member = await audioProjectPath(root, `${relative}/${entry.path}`);
+                if (digest(await readFile(member)) !== digest(entry.data))
+                    throw audioError('audio_representation_conflict');
+            }
+        }
+        else {
+            await rename(staging, directory);
+            const published = await open(dirname(directory), 'r');
+            try {
+                await published.sync();
+            }
+            finally {
+                await published.close();
+            }
+        }
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+    return { representationSetHash, sourceContentHash: source.contentHash, rendererBuildHash: engine.rendererBuildHash,
+        modulePath: `${relative}/sound.mjs`, manifestPath: `${relative}/manifest.json`,
+        files: [...files.map(entry => ({ path: `${relative}/${entry.path}`, contentHash: entry.contentHash, size: entry.size })),
+            { path: `${relative}/manifest.json`, contentHash: digest(manifestBytes), size: manifestBytes.length }] };
+}