@playcraft/cli 0.1.66 → 0.1.67

package/dist/workspace-runtime/workspaces/level-editor-atomic.js

@@ -0,0 +1,424 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, realpath, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { LevelEditorError, applyLevelEditorCommandBatch, applyLevelEditorHistoryBatch, levelEditorCanonicalJson, hashOperationPayload, } from '@playcraft/common/cloud-workspace/runtime';
+import { historyDirectory, readHistoryText, readLevelEditorHistory, writeLevelEditorHistory, levelEditorHistoryRequestDigest, assertLevelEditorHistoryScope, } from './level-editor-history-store.js';
+import { acquireParameterSkillLease } from './parameter-initialization-skill-transaction.js';
+import { readParameterAgentFile } from './parameter-agent-inputs.js';
+import { serializeLevelEditorDocument, parseLevelEditorDocument } from './level-editor-format.js';
+import { validateLevelEditorExtensions } from './level-editor-extensions.js';
+import { resolveWorkspaceFile } from './files.js';
+import { openSharedFile } from './shared-write.js';
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const contexts = new Map();
+export function registerLevelEditorContext(root, context) {
+    contexts.delete(root);
+    contexts.set(root, context);
+    if (contexts.size > 128)
+        contexts.delete(contexts.keys().next().value);
+}
+export function levelEditorContext(root, context) {
+    return context ?? contexts.get(root);
+}
+async function location(root, context) {
+    const current = await historyDirectory(root, context);
+    const parent = join(dirname(current), 'atomic');
+    // private
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    const parentStat = await lstat(parent);
+    if (!parentStat.isDirectory() || parentStat.isSymbolicLink())
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    const directory = join(parent, hash(await realpath(root)));
+    // private
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    return { directory, current, pending: join(directory, 'active.json') };
+}
+async function pending(root, context) {
+    if (!context.state.config.stateDir)
+        return undefined;
+    try {
+        await lstat(resolve(context.state.config.stateDir, 'level-editor-history'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const paths = await location(root, context);
+    try {
+        const value = JSON.parse(await readHistoryText(paths.pending));
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        const record = value;
+        if (typeof record.requestId !== 'string' ||
+            record.requestId.length > 128 ||
+            typeof record.scope !== 'string' ||
+            !/^[a-f0-9]{64}$/.test(record.scope))
+            throw new Error();
+        if (record.scope !== basename(paths.current))
+            throw new LevelEditorError('level_editor_recovery_scope_conflict');
+        return { ...paths, requestId: record.requestId };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        if (error instanceof LevelEditorError)
+            throw error;
+        throw new LevelEditorError('level_editor_recovery_conflict');
+    }
+}
+export async function hasPendingLevelEditorTransaction(root, context) {
+    return !!(await pending(root, context));
+}
+export async function assertNoPendingLevelEditorTransaction(root, context) {
+    if (await pending(root, context))
+        throw new LevelEditorError('level_editor_recovery_required');
+}
+async function syncDirectory(path) {
+    const handle = await open(path, constants.O_RDONLY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function writeMarker(path, text) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        // private
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await handle.writeFile(text);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, path);
+        await syncDirectory(dirname(path));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+function expectedContract(snapshot, request) {
+    if (snapshot.status !== 'ready' ||
+        !snapshot.definition ||
+        snapshot.definition.editorId !== request.editorId ||
+        snapshot.definition.dataContractVersion !== request.dataContractVersion)
+        throw new LevelEditorError('level_editor_not_ready');
+    for (const key of [
+        'sourceFingerprint',
+        'bindingContractHash',
+        'schemaHash',
+        'executionContractHash',
+    ])
+        if (snapshot[key] !== request[key])
+            throw new LevelEditorError('level_editor_source_conflict');
+    const ids = Object.keys(snapshot.definition.documents).sort();
+    if (JSON.stringify(ids) !== JSON.stringify(Object.keys(request.expectedDocuments).sort()))
+        throw new LevelEditorError('level_editor_baseline_incomplete');
+}
+function written(receipt) {
+    const results = receipt.batch.files.map(({ documentId, path, contentHash, size, revision }) => ({
+        documentId,
+        path,
+        contentHash,
+        size,
+        revision,
+    }));
+    return { ...results[0], results };
+}
+async function finish(root, context, receipt, read) {
+    const request = receipt.request;
+    if (request.version !== 2 || !receipt.batch)
+        throw new LevelEditorError('level_editor_history_invalid');
+    assertLevelEditorHistoryScope(context);
+    if (context.state.journal?.destroyed() ||
+        (context.operation.leaseFence ?? 0) < context.state.acceptedLeaseFence)
+        throw new LevelEditorError('level_editor_source_conflict');
+    const snapshot = await read();
+    expectedContract(snapshot, request);
+    const batch = receipt.batch;
+    for (const [id, baseline] of Object.entries(batch.baselines)) {
+        if (snapshot.definition.documents[id]?.path !== baseline.path)
+            throw new LevelEditorError('level_editor_recovery_conflict');
+        const file = batch.files.find((file) => file.documentId === id);
+        const revision = snapshot.revisions[id];
+        if ((snapshot.documentHashes[id] !== baseline.contentHash &&
+            snapshot.documentHashes[id] !== file?.contentHash) ||
+            (snapshot.documentHashes[id] === file?.contentHash
+                ? revision !== baseline.revision && revision !== baseline.revision + 1
+                : revision !== baseline.revision))
+            throw new LevelEditorError('level_editor_recovery_conflict');
+    }
+    const next = { ...snapshot.documents };
+    for (const file of batch.files) {
+        const before = await parseLevelEditorDocument(root, snapshot.definition.documents[file.documentId], Buffer.from(file.beforeBytes, 'base64').toString('utf8'));
+        const after = await parseLevelEditorDocument(root, snapshot.definition.documents[file.documentId], Buffer.from(file.afterBytes, 'base64').toString('utf8'));
+        const entry = batch.documents.find((item) => item.documentId === file.documentId);
+        if (levelEditorCanonicalJson(before) !== levelEditorCanonicalJson(entry.before) ||
+            levelEditorCanonicalJson(after) !== levelEditorCanonicalJson(entry.after))
+            throw new LevelEditorError('level_editor_history_invalid');
+        next[file.documentId] = after;
+    }
+    const before = {
+        ...snapshot.documents,
+        ...Object.fromEntries(batch.documents.map((item) => [item.documentId, item.before])),
+    };
+    let authorized;
+    if (request.history) {
+        const original = await readLevelEditorHistory(root, context, request.history.requestId);
+        if (!original?.batch ||
+            original.phase !== 'confirmed' ||
+            original.request.history ||
+            levelEditorCanonicalJson(original.batch.commands) !==
+                levelEditorCanonicalJson(request.commands))
+            throw new LevelEditorError('level_editor_history_missing');
+        for (const key of [
+            'editorId',
+            'dataContractVersion',
+            'sourceFingerprint',
+            'bindingContractHash',
+            'schemaHash',
+            'executionContractHash',
+        ])
+            if (original.request[key] !== request[key])
+                throw new LevelEditorError('level_editor_source_conflict');
+        authorized = applyLevelEditorHistoryBatch(snapshot.definition, before, original.batch, request.history.direction, snapshot.schemas);
+    }
+    else
+        authorized = applyLevelEditorCommandBatch(snapshot.definition, before, batch.commands, snapshot.schemas);
+    if (authorized.results.length !== batch.documents.length ||
+        authorized.results.some((item) => levelEditorCanonicalJson(item.data) !== levelEditorCanonicalJson(next[item.documentId])))
+        throw new LevelEditorError('level_editor_history_invalid');
+    if ((await validateLevelEditorExtensions(root, snapshot.definition, next)).some((item) => item.severity === 'error'))
+        throw new LevelEditorError('level_editor_validation_failed');
+    for (const file of batch.files) {
+        const path = await resolveWorkspaceFile(root, file.path), stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1)
+            throw new LevelEditorError('level_editor_file_invalid');
+        const current = hash(await readParameterAgentFile(root, file.path));
+        if (current === file.contentHash)
+            continue;
+        if (current !== batch.baselines[file.documentId].contentHash)
+            throw new LevelEditorError('level_editor_recovery_conflict');
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            const handle = await openSharedFile(root, temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW);
+            try {
+                await handle.writeFile(Buffer.from(file.afterBytes, 'base64'));
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            if (hash(await readParameterAgentFile(root, file.path)) !== current)
+                throw new LevelEditorError('level_editor_recovery_conflict');
+            assertLevelEditorHistoryScope(context);
+            if (context.state.journal?.destroyed() ||
+                (context.operation.leaseFence ?? 0) < context.state.acceptedLeaseFence)
+                throw new LevelEditorError('level_editor_source_conflict');
+            await rename(temporary, path);
+            await syncDirectory(dirname(path));
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    const latest = await read();
+    expectedContract(latest, request);
+    for (const [id, baseline] of Object.entries(batch.baselines))
+        if (latest.documentHashes[id] !==
+            (batch.files.find((file) => file.documentId === id)?.contentHash ?? baseline.contentHash))
+            throw new LevelEditorError('level_editor_recovery_conflict');
+    await writeLevelEditorHistory(root, context, { ...receipt, phase: 'confirmed' });
+    const paths = await location(root, context);
+    await rm(paths.pending, { force: true });
+    await syncDirectory(paths.directory);
+    return written(receipt);
+}
+export async function recoverPendingLevelEditorTransaction(root, context, read) {
+    registerLevelEditorContext(root, context);
+    const active = await pending(root, context);
+    if (!active)
+        return;
+    const lease = await acquireParameterSkillLease(active.directory, async () => {
+        throw new LevelEditorError('level_editor_recovery_conflict');
+    });
+    try {
+        const current = await pending(root, context);
+        if (!current)
+            return;
+        const probeContext = 'operation' in context ? context : undefined;
+        // The marker is only a read barrier; the operation journal and private history remain authoritative.
+        const raw = JSON.parse(await readHistoryText(join(active.current, `${hash(active.requestId)}.json`)));
+        const operation = (probeContext?.operation.clientRequestId === active.requestId
+            ? probeContext.operation
+            : undefined) ?? context.state.journal?.getOperationById(raw.batch?.operationId ?? '');
+        if (!operation ||
+            operation.kind !== 'level-editor.transaction' ||
+            operation.clientRequestId !== active.requestId)
+            throw new LevelEditorError('level_editor_recovery_conflict');
+        const owner = { state: context.state, operation };
+        const receipt = await readLevelEditorHistory(root, owner, active.requestId);
+        if (!receipt?.batch || operation.payloadHash !== hashOperationPayload(receipt.request))
+            throw new LevelEditorError('level_editor_recovery_conflict');
+        await finish(root, owner, receipt, read);
+    }
+    finally {
+        await lease.release();
+    }
+}
+export async function transactLevelEditorBatch(root, revisions, request, context, read) {
+    if (!context)
+        throw new LevelEditorError('level_editor_atomic_context_required');
+    registerLevelEditorContext(root, context);
+    assertLevelEditorHistoryScope(context);
+    if (context.operation.kind !== 'level-editor.transaction' ||
+        context.operation.clientRequestId !== request.requestId ||
+        context.operation.payloadHash !== hashOperationPayload(request))
+        throw new LevelEditorError('level_editor_history_scope_invalid');
+    if (context.state.journal.destroyed() ||
+        (context.operation.leaseFence ?? 0) < context.state.acceptedLeaseFence)
+        throw new LevelEditorError('level_editor_source_conflict');
+    const paths = await location(root, context);
+    const lease = await acquireParameterSkillLease(paths.directory, async () => {
+        throw new LevelEditorError('level_editor_recovery_conflict');
+    });
+    try {
+        const active = await pending(root, context);
+        if (active && active.requestId !== request.requestId)
+            throw new LevelEditorError('level_editor_recovery_required');
+        const previous = await readLevelEditorHistory(root, context, request.requestId);
+        if (previous) {
+            if (previous.requestDigest !== levelEditorHistoryRequestDigest(request) ||
+                !previous.batch ||
+                previous.batch.operationId !== context.operation.operationId)
+                throw new LevelEditorError('level_editor_history_request_conflict');
+            if (previous.phase === 'confirmed') {
+                const snapshot = await read();
+                expectedContract(snapshot, request);
+                if (Object.entries(previous.batch.baselines).some(([id, baseline]) => {
+                    const file = previous.batch.files.find((file) => file.documentId === id), revision = snapshot.revisions[id];
+                    return (snapshot.documentHashes[id] !== (file?.contentHash ?? baseline.contentHash) ||
+                        (file
+                            ? revision !== baseline.revision && revision !== file.revision
+                            : revision !== baseline.revision));
+                }))
+                    throw new LevelEditorError('revision_conflict');
+                return written(previous);
+            }
+            if (!active)
+                await writeMarker(paths.pending, JSON.stringify({ requestId: request.requestId, scope: basename(paths.current) }));
+            return await finish(root, context, previous, read);
+        }
+        const snapshot = await read();
+        expectedContract(snapshot, request);
+        for (const [id, baseline] of Object.entries(request.expectedDocuments))
+            if (snapshot.documentHashes[id] !== baseline.contentHash ||
+                snapshot.revisions[id] !== baseline.revision)
+                throw new LevelEditorError('revision_conflict');
+        let outcome;
+        if (request.history) {
+            const original = await readLevelEditorHistory(root, context, request.history.requestId);
+            if (!original?.batch ||
+                original.phase !== 'confirmed' ||
+                original.request.history ||
+                levelEditorCanonicalJson(original.batch.commands) !==
+                    levelEditorCanonicalJson(request.commands))
+                throw new LevelEditorError('level_editor_history_missing');
+            for (const key of [
+                'editorId',
+                'dataContractVersion',
+                'sourceFingerprint',
+                'bindingContractHash',
+                'schemaHash',
+                'executionContractHash',
+            ])
+                if (original.request[key] !== request[key])
+                    throw new LevelEditorError('level_editor_source_conflict');
+            outcome = applyLevelEditorHistoryBatch(snapshot.definition, snapshot.documents, original.batch, request.history.direction, snapshot.schemas);
+        }
+        else
+            outcome = applyLevelEditorCommandBatch(snapshot.definition, snapshot.documents, request.commands, snapshot.schemas);
+        if (!outcome.results.length)
+            throw new LevelEditorError('level_editor_empty_command');
+        const files = [];
+        const documents = [];
+        let bytes = 0;
+        const next = { ...snapshot.documents };
+        for (const result of outcome.results) {
+            const declaration = snapshot.definition.documents[result.documentId];
+            if (!declaration ||
+                declaration.path === snapshot.definitionPath ||
+                Object.values(snapshot.definition.documents).some((item) => item.schema === declaration.path) ||
+                declaration.path === '.playcraft/workspace.json')
+                throw new LevelEditorError('level_editor_file_invalid');
+            const before = await readParameterAgentFile(root, declaration.path);
+            if (hash(before) !== request.expectedDocuments[result.documentId]?.contentHash)
+                throw new LevelEditorError('revision_conflict');
+            const after = Buffer.from(await serializeLevelEditorDocument(root, declaration, before.toString('utf8'), result.changes, result.data));
+            bytes += before.length + after.length;
+            if (bytes > 4 * 1024 * 1024 || after.length > 2 * 1024 * 1024)
+                throw new LevelEditorError('level_editor_document_budget');
+            files.push({
+                documentId: result.documentId,
+                path: declaration.path,
+                beforeBytes: before.toString('base64'),
+                afterBytes: after.toString('base64'),
+                contentHash: hash(after),
+                size: after.length,
+                revision: request.expectedDocuments[result.documentId].revision + 1,
+            });
+            documents.push({
+                documentId: result.documentId,
+                before: snapshot.documents[result.documentId],
+                after: result.data,
+            });
+            next[result.documentId] = result.data;
+        }
+        if ((await validateLevelEditorExtensions(root, snapshot.definition, next)).some((item) => item.severity === 'error'))
+            throw new LevelEditorError('level_editor_validation_failed');
+        const baselines = Object.fromEntries(Object.entries(snapshot.definition.documents).map(([id, doc]) => [
+            id,
+            { path: doc.path, ...request.expectedDocuments[id] },
+        ]));
+        const first = files[0];
+        const receipt = {
+            request,
+            requestDigest: levelEditorHistoryRequestDigest(request),
+            phase: 'prepared',
+            command: request.commands[0],
+            documentId: first.documentId,
+            before: null,
+            after: null,
+            path: first.path,
+            contentHash: first.contentHash,
+            size: first.size,
+            batch: {
+                commands: request.commands,
+                documents,
+                files,
+                baselines,
+                operationId: context.operation.operationId,
+            },
+        };
+        await writeLevelEditorHistory(root, context, receipt);
+        await writeMarker(paths.pending, JSON.stringify({ requestId: request.requestId, scope: basename(paths.current) }));
+        try {
+            return await finish(root, context, receipt, read);
+        }
+        catch {
+            throw new LevelEditorError('level_editor_transaction_uncertain');
+        }
+    }
+    finally {
+        await lease.release();
+    }
+}

package/dist/workspace-runtime/workspaces/level-editor-extensions.js

@@ -0,0 +1,140 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { LevelEditorError, isLevelEditorJson, levelEditorDiagnosticSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { readParameterAgentFile } from './parameter-agent-inputs.js';
+const hash = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const LIMIT = 4 * 1024 * 1024;
+const OUTPUT_LIMIT = 4 * 1024 * 1024;
+// Project modules receive JSON values only. No host callbacks, imports, filesystem, process or network globals.
+const BOOTSTRAP = String.raw `
+const vm = require('node:vm');
+let input = ''; process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; if (Buffer.byteLength(input) > 5*1024*1024) process.exit(2); });
+process.stdin.on('end', async () => {
+ const keepalive = setInterval(() => {}, 1000);
+ try {
+  const request = JSON.parse(input);
+  const context = vm.createContext(Object.assign(Object.create(null), { __input: JSON.stringify(request.input) }), { codeGeneration: { strings: false, wasm: false } });
+  const module = new vm.SourceTextModule(request.source, { context, importModuleDynamically: () => { throw new Error('imports_forbidden'); } });
+  if (module.dependencySpecifiers.length) throw new Error('imports_forbidden');
+  await module.link(() => { throw new Error('imports_forbidden'); });
+  await module.evaluate({ timeout: request.timeoutMs });
+  context.__call = module.namespace[request.method] ?? (request.method === 'validate' ? module.namespace.default : undefined);
+  if (typeof context.__call !== 'function') throw new Error('missing_export');
+  const result = await new vm.Script('Promise.resolve(__call(JSON.parse(__input))).then(value => JSON.stringify(value))').runInContext(context, { timeout: request.timeoutMs });
+  if (typeof result !== 'string' || Buffer.byteLength(result) > 4*1024*1024) throw new Error('output_limit');
+  process.stdout.write(result);
+ } catch { process.exitCode = 1; }
+ finally { clearInterval(keepalive); }
+});
+`;
+export function levelEditorExtensionPaths(definition) {
+    return [
+        ...new Set([
+            ...Object.values(definition.documents).flatMap((document) => document.provider ? [document.provider.module] : []),
+            ...(definition.extensions?.validators ?? []).map((validator) => validator.module),
+            ...Object.values(definition.extensions?.views ?? {}).map((view) => view.entry),
+        ]),
+    ].sort();
+}
+export async function executeLevelEditorModule(root, module, method, input, timeoutMs = 1000) {
+    if (!module.endsWith('.mjs') ||
+        !Number.isSafeInteger(timeoutMs) ||
+        timeoutMs < 10 ||
+        timeoutMs > 10_000)
+        throw new LevelEditorError('level_editor_extension_module_invalid');
+    const bytes = await readParameterAgentFile(root, module, 256 * 1024);
+    const request = JSON.stringify({ source: bytes.toString('utf8'), method, input, timeoutMs });
+    if (Buffer.byteLength(request) > LIMIT)
+        throw new LevelEditorError('level_editor_extension_input_budget');
+    const output = await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, ['--experimental-vm-modules', '--no-addons', '--max-old-space-size=64', '-e', BOOTSTRAP], {
+            cwd: root,
+            env: { LANG: 'C.UTF-8', TZ: 'UTC' },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const chunks = [];
+        let size = 0, errorSize = 0;
+        let failure;
+        const fail = (code) => {
+            failure ??= new LevelEditorError(code);
+            child.kill('SIGKILL');
+        };
+        const timer = setTimeout(() => fail('level_editor_extension_timeout'), timeoutMs + 150);
+        child.stdout.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > OUTPUT_LIMIT)
+                fail('level_editor_extension_output_budget');
+            else
+                chunks.push(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            errorSize += chunk.length;
+            if (errorSize > 64 * 1024)
+                fail('level_editor_extension_output_budget');
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            reject(new LevelEditorError('level_editor_extension_failed'));
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (failure)
+                reject(failure);
+            else if (code !== 0)
+                reject(new LevelEditorError('level_editor_extension_failed'));
+            else
+                resolve(Buffer.concat(chunks));
+        });
+        child.stdin.on('error', () => { });
+        child.stdin.end(request);
+    });
+    if (hash(await readParameterAgentFile(root, module, 256 * 1024)) !== hash(bytes))
+        throw new LevelEditorError('level_editor_sources_changed');
+    try {
+        const value = JSON.parse(output.toString('utf8'));
+        if (!isLevelEditorJson(value))
+            throw new Error();
+        return value;
+    }
+    catch {
+        throw new LevelEditorError('level_editor_extension_output_invalid');
+    }
+}
+export async function validateLevelEditorExtensions(root, definition, documents) {
+    const diagnostics = [];
+    for (const validator of definition.extensions?.validators ?? []) {
+        const result = (await executeLevelEditorModule(root, validator.module, 'validate', { documents, definition }, validator.timeoutMs));
+        if (!result ||
+            Object.keys(result).some((key) => key !== 'diagnostics') ||
+            !Array.isArray(result.diagnostics) ||
+            result.diagnostics.length > 64)
+            throw new LevelEditorError('level_editor_extension_output_invalid');
+        const nodes = new Set();
+        const visit = (node) => {
+            nodes.add(node.id);
+            node.children?.forEach(visit);
+        };
+        visit(definition.view);
+        for (const item of result.diagnostics) {
+            const parsed = levelEditorDiagnosticSchema.safeParse(item);
+            if (!parsed.success)
+                throw new LevelEditorError('level_editor_extension_output_invalid');
+            const value = parsed.data;
+            if ((value.documentId && !Object.hasOwn(definition.documents, value.documentId)) ||
+                (value.bindingId && !Object.hasOwn(definition.bindings, value.bindingId)) ||
+                (value.documentId &&
+                    value.bindingId &&
+                    definition.bindings[value.bindingId]?.documentId !== value.documentId) ||
+                (value.componentId && !nodes.has(value.componentId)) ||
+                value.path?.some((part) => typeof part === 'number'
+                    ? !Number.isSafeInteger(part) || part < 0
+                    : ['__proto__', 'prototype', 'constructor'].includes(part)))
+                throw new LevelEditorError('level_editor_extension_output_invalid');
+            diagnostics.push(value);
+            if (diagnostics.length > 256)
+                throw new LevelEditorError('level_editor_extension_output_invalid');
+        }
+    }
+    return diagnostics;
+}

package/dist/workspace-runtime/workspaces/level-editor-format.js

@@ -0,0 +1,75 @@
+import JSON5 from 'json5';
+import { isAlias, isCollection, isNode, isPair, isScalar, parseDocument, visit } from 'yaml';
+import { LevelEditorError, isLevelEditorJson, levelEditorCanonicalJson, } from '@playcraft/common/cloud-workspace/runtime';
+import { editLevelEditorJson5 } from './level-editor-json5.js';
+import { executeLevelEditorModule } from './level-editor-extensions.js';
+function yamlDocument(text) {
+    const document = parseDocument(text, {
+        version: '1.2',
+        uniqueKeys: true,
+        strict: true,
+        customTags: [],
+    });
+    if (document.errors.length || document.warnings.length)
+        throw new LevelEditorError('level_editor_yaml_invalid');
+    visit(document, (_key, node) => {
+        if (isAlias(node) ||
+            (isPair(node) && (!isScalar(node.key) || typeof node.key.value !== 'string')) ||
+            (isNode(node) &&
+                (('anchor' in node && node.anchor) ||
+                    (node.tag && !node.tag.startsWith('tag:yaml.org,2002:')))))
+            throw new LevelEditorError('level_editor_yaml_feature_unsupported');
+    });
+    return document;
+}
+export async function parseLevelEditorDocument(root, declaration, text) {
+    let value;
+    if (declaration.provider)
+        value = await executeLevelEditorModule(root, declaration.provider.module, 'parse', { text }, declaration.provider.timeoutMs);
+    else if (declaration.format === 'yaml')
+        value = yamlDocument(text).toJS({ maxAliasCount: 0 });
+    else if (declaration.format === 'json')
+        value = JSON.parse(text);
+    else if (declaration.format === 'json5' || declaration.format === undefined)
+        value = JSON5.parse(text);
+    else
+        throw new LevelEditorError('level_editor_format_unsupported');
+    if (!isLevelEditorJson(value))
+        throw new LevelEditorError('level_editor_document_invalid');
+    return value;
+}
+export async function serializeLevelEditorDocument(root, declaration, source, changes, data) {
+    let text;
+    if (declaration.provider) {
+        const value = await executeLevelEditorModule(root, declaration.provider.module, 'serialize', { text: source, data, changes }, declaration.provider.timeoutMs);
+        if (typeof value !== 'string')
+            throw new LevelEditorError('level_editor_extension_output_invalid');
+        text = value;
+    }
+    else if (declaration.format === 'yaml') {
+        const document = yamlDocument(source);
+        for (const change of changes) {
+            const old = document.getIn(change.path, true);
+            if (isCollection(old)) {
+                let commented = false;
+                visit(old, (_key, node) => {
+                    if (isNode(node) && (node.comment || node.commentBefore))
+                        commented = true;
+                });
+                if (commented)
+                    throw new LevelEditorError('level_editor_comment_preservation_required');
+            }
+            if (change.op === 'remove')
+                document.deleteIn(change.path);
+            else
+                document.setIn(change.path, change.value);
+        }
+        text = document.toString({ lineWidth: 0 });
+    }
+    else
+        text = editLevelEditorJson5(source, changes, data);
+    if (levelEditorCanonicalJson(await parseLevelEditorDocument(root, declaration, text)) !==
+        levelEditorCanonicalJson(data))
+        throw new LevelEditorError('level_editor_serialization_mismatch');
+    return text;
+}