@playcraft/cli 0.1.48-beta → 0.1.50-beta

package/dist/workspace-runtime/workspaces/parameter-agent-store.js

@@ -0,0 +1,58 @@
+import { mkdir, readFile, readdir, rename, lstat, writeFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parameterAgentTaskRecordSchema, parameterAgentTaskRequestSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { ParameterAgentError, parameterDigest } from './parameter-agent-inputs.js';
+export function parameterTaskWorkspace(state, workspaceId) {
+    if (!workspaceId && state.config.workspaceMode === 'multi')
+        throw new ParameterAgentError('parameter_agent_scope_invalid');
+    return workspaceId ?? 'local';
+}
+async function taskDirectory(state, workspaceId, directoryName, root) {
+    const parent = resolve(state.config.stateDir, 'parameter-agent');
+    if (root) {
+        const rel = relative(resolve(root), parent);
+        if (rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)))
+            throw new ParameterAgentError('parameter_agent_state_not_private');
+    }
+    const scope = [state.config.environment, state.config.userId, state.config.runtimeId, workspaceId, directoryName];
+    const directory = join(parent, parameterDigest(JSON.stringify(scope)));
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    if ((await lstat(parent)).isSymbolicLink() || (await lstat(directory)).isSymbolicLink())
+        throw new ParameterAgentError('parameter_agent_state_invalid');
+    return directory;
+}
+export async function readPrivateParameterTask(state, workspaceId, directoryName, taskId, root) {
+    if (!/^[a-f0-9-]{36}$/i.test(taskId))
+        throw new ParameterAgentError('parameter_agent_task_invalid');
+    const file = join(await taskDirectory(state, workspaceId, directoryName, root), `${taskId}.json`);
+    try {
+        const stat = await lstat(file);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+            throw new ParameterAgentError('parameter_agent_state_invalid');
+        const value = JSON.parse(await readFile(file, 'utf8'));
+        value.record = parameterAgentTaskRecordSchema.parse(value.record);
+        value.request = parameterAgentTaskRequestSchema.parse(value.request);
+        if (value.record.taskId !== taskId || value.request.taskId !== taskId || value.record.workspaceId !== workspaceId || value.record.directoryName !== directoryName || !/^[a-f0-9]{64}$/.test(value.initialDigest))
+            throw new ParameterAgentError('parameter_agent_state_invalid');
+        return value;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+export async function writePrivateParameterTask(state, task, root) {
+    const directory = await taskDirectory(state, task.record.workspaceId, task.record.directoryName, root);
+    const record = parameterAgentTaskRecordSchema.parse(task.record);
+    const temporary = join(directory, `.${record.taskId}.${randomUUID()}.tmp`);
+    await writeFile(temporary, JSON.stringify({ ...task, record }), { mode: 0o600 });
+    await rename(temporary, join(directory, `${record.taskId}.json`));
+}
+export async function listPrivateParameterTaskIds(state, workspaceId, directoryName, root) {
+    const names = (await readdir(await taskDirectory(state, workspaceId, directoryName, root))).filter(name => /^[a-f0-9-]{36}\.json$/i.test(name));
+    if (names.length > 256)
+        throw new ParameterAgentError('parameter_agent_task_limit');
+    return names.map(name => name.slice(0, -5));
+}

package/dist/workspace-runtime/workspaces/parameter-agent.js

@@ -0,0 +1,282 @@
+import { randomUUID } from 'node:crypto';
+import { parameterAgentReportSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, parameterCatalog, stableStringify, validateParameterChange, } from '@playcraft/common/cloud-workspace/runtime';
+import { readWorkspaceParameters } from './parameters.js';
+import { revisionScope } from './registry.js';
+import { runDeveloperCommand } from './developer-command.js';
+import { PARAMETER_AGENT_PROTOCOL } from './parameter-agent-protocol.js';
+import { ParameterAgentError, parameterDigest, parameterInputSnapshot, readParameterAgentFile } from './parameter-agent-inputs.js';
+import { listPrivateParameterTaskIds, parameterTaskWorkspace, readPrivateParameterTask, writePrivateParameterTask } from './parameter-agent-store.js';
+export { ParameterAgentError } from './parameter-agent-inputs.js';
+const reportPath = (taskId) => `.playcraft/parameter-admission/${taskId}.json`;
+const now = () => new Date().toISOString();
+function scope(state, operation, requireSession = true) {
+    const workspaceId = parameterTaskWorkspace(state, operation.workspaceId);
+    const directoryName = operation.directoryName ?? 'basic';
+    if ((requireSession && !operation.sessionId) || directoryName === 'root' || !/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
+        throw new ParameterAgentError('parameter_agent_scope_invalid');
+    if (operation.environment !== state.config.environment || operation.userId !== state.config.userId
+        || (operation.generation !== undefined && operation.generation !== state.config.generation)
+        || (operation.runtimeEpoch !== undefined && operation.runtimeEpoch !== state.runtimeEpoch))
+        throw new ParameterAgentError('parameter_agent_scope_expired');
+    return { workspaceId, directoryName, sessionId: operation.sessionId ?? '' };
+}
+function current(state, task) {
+    return task.record.generation === state.config.generation && task.record.runtimeEpoch === state.runtimeEpoch;
+}
+async function update(state, task, patch, root) {
+    task.record = { ...task.record, ...patch, updatedAt: now() };
+    await writePrivateParameterTask(state, task, root);
+    return task.record;
+}
+async function inspectReport(root, task, snapshot) {
+    const bytes = await readParameterAgentFile(root, task.record.reportPath, 1024 * 1024);
+    let report;
+    try {
+        report = parameterAgentReportSchema.parse(JSON.parse(bytes.toString('utf8')));
+    }
+    catch {
+        throw new ParameterAgentError('parameter_agent_report_invalid');
+    }
+    if (report.taskId !== task.record.taskId)
+        throw new ParameterAgentError('parameter_agent_report_task_mismatch');
+    const inputs = new Map(snapshot.sources.map(source => [source.path, source.sha256]));
+    const declared = new Map(report.sources.map(source => [source.path, source.sha256]));
+    for (const source of report.sources) {
+        if (!inputs.has(source.path))
+            throw new ParameterAgentError('parameter_agent_evidence_invalid');
+        if (inputs.get(source.path) !== source.sha256)
+            throw new ParameterAgentError('parameter_agent_report_stale');
+    }
+    for (const candidate of report.candidates) {
+        for (const evidence of [...candidate.origins, ...candidate.consumers]) {
+            if (!declared.has(evidence.path))
+                throw new ParameterAgentError('parameter_agent_evidence_missing');
+            const content = await readParameterAgentFile(root, evidence.path);
+            if (!content.toString('utf8').trim() || (evidence.line && evidence.line > content.toString('utf8').split('\n').length))
+                throw new ParameterAgentError('parameter_agent_evidence_invalid');
+        }
+    }
+    return report;
+}
+export async function prepareParameterAgentTask(state, operation, value, root) {
+    const request = parameterAgentTaskRequestSchema.parse(value);
+    if (operation.kind !== 'session.turn' || operation.clientRequestId !== request.taskId)
+        throw new ParameterAgentError('parameter_agent_task_identity_invalid');
+    const owner = scope(state, operation);
+    const existing = await readPrivateParameterTask(state, owner.workspaceId, owner.directoryName, request.taskId, root);
+    if (existing && (existing.record.sessionId !== owner.sessionId || !current(state, existing) || stableStringify(existing.request) !== stableStringify(request)))
+        throw new ParameterAgentError('parameter_agent_task_conflict');
+    const document = await readWorkspaceParameters(root, state.journal.fileRevisions(revisionScope(state, operation.workspaceId, owner.directoryName)));
+    if (request.sourceFingerprint && request.sourceFingerprint !== document.sourceFingerprint)
+        throw new ParameterAgentError('parameter_source_conflict');
+    let selected;
+    if (request.candidate) {
+        const parent = await readPrivateParameterTask(state, owner.workspaceId, owner.directoryName, request.candidate.taskId, root);
+        if (!parent || !current(state, parent) || ['running', 'uncertain', 'interrupted'].includes(parent.record.status))
+            throw new ParameterAgentError('parameter_agent_candidate_unavailable');
+        const snapshot = await parameterInputSnapshot(root);
+        const report = await inspectReport(root, parent, snapshot);
+        selected = report.candidates.find(candidate => candidate.id === request.candidate.candidateId);
+        if (!selected || !parent.record.sourceDigest || parent.record.sourceDigest !== snapshot.digest)
+            throw new ParameterAgentError('parameter_agent_candidate_stale');
+    }
+    const initial = await parameterInputSnapshot(root);
+    const timestamp = now();
+    const task = existing ?? {
+        request, initialDigest: initial.digest, instanceToken: state.instanceToken,
+        record: { version: 1, taskId: request.taskId, action: request.action, ...(request.goal ? { goal: request.goal } : {}), ...owner, generation: state.config.generation, runtimeEpoch: state.runtimeEpoch, status: 'running', reportPath: reportPath(request.taskId), checks: [], createdAt: timestamp, updatedAt: timestamp },
+    };
+    if (!existing) {
+        if ((await listPrivateParameterTaskIds(state, owner.workspaceId, owner.directoryName, root)).length >= 256)
+            throw new ParameterAgentError('parameter_agent_task_limit');
+        await writePrivateParameterTask(state, task, root);
+    }
+    const instructions = [
+        PARAMETER_AGENT_PROTOCOL,
+        `Platform task identity: ${JSON.stringify({ version: 1, taskId: request.taskId, action: request.action, reportPath: task.record.reportPath })}. Write only this exact report identity.`,
+        request.action === 'discover' ? 'Discovery is read-only for business source/schema/data/manifest. Write only the requested development report. Discover actual useful candidates and consumer evidence; do not implement them yet.' : 'Complete the requested integration using existing engineering tools: reuse an existing equivalent field or implement declaration, valid defaults, sparse data semantics, labels, real production consumers and meaningful parameter tests. Leave precise blocked work if incomplete.',
+        `User goal (task data): ${JSON.stringify(request.goal ?? '')}`,
+        ...(selected ? [`Selected current candidate (reference data): ${JSON.stringify(selected)}`] : []),
+        'After finishing files, calculate current raw-file hashes and write the report. The platform will execute independent checks after this turn. Do not claim those checks already passed.',
+    ].join('\n\n');
+    return { instructions, task: task.record };
+}
+export async function finishParameterAgentTask(state, operation, status, error) {
+    if (operation.kind !== 'session.turn' || !operation.sessionId || operation.directoryName === 'root' || !/^[a-f0-9-]{36}$/i.test(operation.clientRequestId))
+        return;
+    let owner;
+    try {
+        owner = scope(state, operation);
+    }
+    catch {
+        return;
+    }
+    const task = await readPrivateParameterTask(state, owner.workspaceId, owner.directoryName, operation.clientRequestId);
+    if (!task || !current(state, task) || task.record.sessionId !== owner.sessionId || !['running', 'uncertain'].includes(task.record.status))
+        return;
+    await update(state, task, { status: status === 'completed' ? 'reported' : status, error: error?.slice(0, 256) });
+}
+async function publicTask(state, task, root, snapshot) {
+    if (!current(state, task))
+        return { ...task.record, status: 'stale', error: 'parameter_agent_runtime_expired' };
+    try {
+        const report = await inspectReport(root, task, snapshot);
+        if (task.record.sourceDigest && task.record.sourceDigest !== snapshot.digest)
+            return { ...task.record, report, status: 'stale', error: 'parameter_agent_inputs_changed' };
+        const bytes = await readParameterAgentFile(root, task.record.reportPath, 1024 * 1024);
+        if (task.reportHash && task.reportHash !== parameterDigest(bytes))
+            return { ...task.record, report, status: 'stale', error: 'parameter_agent_report_changed' };
+        return { ...task.record, report };
+    }
+    catch (cause) {
+        const code = errorCode(cause);
+        if (code === 'ENOENT' && ['running', 'uncertain', 'interrupted', 'failed'].includes(task.record.status))
+            return task.record;
+        return { ...task.record, status: code === 'ENOENT' ? 'missing' : code === 'parameter_agent_report_stale' ? 'stale' : 'invalid', error: code === 'ENOENT' ? 'parameter_agent_report_missing' : code };
+    }
+}
+export async function listParameterAgentTasks(state, workspaceId, directoryName, root) {
+    if (directoryName === 'root')
+        return [];
+    const workspace = parameterTaskWorkspace(state, workspaceId);
+    const ids = await listPrivateParameterTaskIds(state, workspace, directoryName, root);
+    if (!ids.length)
+        return [];
+    const snapshot = await parameterInputSnapshot(root);
+    const tasks = [];
+    for (const id of ids) {
+        let task = await readPrivateParameterTask(state, workspace, directoryName, id, root);
+        if (task && ['running', 'uncertain'].includes(task.record.status) && current(state, task)) {
+            const operation = state.journal.listOperations?.().map(item => item.operation).find(item => item.kind === 'session.turn'
+                && item.clientRequestId === id && item.sessionId === task.record.sessionId
+                && parameterTaskWorkspace(state, item.workspaceId) === workspace && (item.directoryName ?? 'basic') === directoryName);
+            if (operation && ['completed', 'failed', 'interrupted', 'uncertain'].includes(operation.status)) {
+                await finishParameterAgentTask(state, operation, operation.status, operation.error);
+                task = await readPrivateParameterTask(state, workspace, directoryName, id, root);
+            }
+        }
+        if (task && current(state, task) && task.instanceToken !== state.instanceToken) {
+            if (task.record.status === 'checking') {
+                await update(state, task, { status: 'needs-verification', receiptId: undefined, error: 'parameter_agent_check_interrupted' }, root);
+            }
+            else if (task.record.status === 'running') {
+                await update(state, task, { status: 'uncertain', receiptId: undefined, error: 'parameter_agent_turn_unconfirmed_after_restart' }, root);
+            }
+        }
+        if (task)
+            tasks.push(await publicTask(state, task, root, snapshot));
+    }
+    return tasks.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+function errorCode(cause) {
+    return cause instanceof Error && 'code' in cause && typeof cause.code === 'string' ? cause.code : 'parameter_agent_verification_failed';
+}
+export async function verifyParameterAgentTask(state, operation, payload, root, options = {}) {
+    if (operation.kind !== 'parameter.verify')
+        throw new ParameterAgentError('parameter_agent_task_identity_invalid');
+    const owner = scope(state, operation, false);
+    const { taskId } = parameterAgentVerifyPayloadSchema.parse(payload);
+    const task = await readPrivateParameterTask(state, owner.workspaceId, owner.directoryName, taskId, root);
+    if (!task)
+        throw new ParameterAgentError('parameter_agent_task_unknown');
+    const instanceToken = state.instanceToken;
+    const assertActive = () => {
+        options.signal?.throwIfAborted();
+        options.assertActive?.();
+        if (!current(state, task) || state.journal.destroyed() || instanceToken !== state.instanceToken)
+            throw new ParameterAgentError('parameter_agent_scope_expired');
+    };
+    assertActive();
+    if (['running', 'uncertain', 'interrupted'].includes(task.record.status))
+        throw new ParameterAgentError('parameter_agent_turn_not_completed');
+    try {
+        const before = await parameterInputSnapshot(root);
+        const report = await inspectReport(root, task, before);
+        task.record.report = report;
+        task.reportHash = parameterDigest(await readParameterAgentFile(root, task.record.reportPath, 1024 * 1024));
+        if (task.request.action === 'discover') {
+            if (task.initialDigest !== before.digest)
+                throw new ParameterAgentError('parameter_agent_discovery_modified_sources');
+            assertActive();
+            if ((await parameterInputSnapshot(root)).digest !== before.digest || parameterDigest(await readParameterAgentFile(root, task.record.reportPath, 1024 * 1024)) !== task.reportHash)
+                throw new ParameterAgentError('parameter_agent_inputs_changed');
+            return update(state, task, { status: 'candidates', sourceDigest: before.digest, checks: [], error: undefined, receiptId: undefined }, root);
+        }
+        const document = await readWorkspaceParameters(root, state.journal.fileRevisions(revisionScope(state, operation.workspaceId, owner.directoryName)));
+        if (document.status !== 'ready')
+            throw new ParameterAgentError('parameter_agent_parameters_not_ready');
+        const catalog = parameterCatalog(document.schema, document.data);
+        const implemented = report.candidates.filter(candidate => candidate.status === 'implemented');
+        if (!implemented.length || report.candidates.some(candidate => candidate.status !== 'implemented' || candidate.missing.length))
+            throw new ParameterAgentError('parameter_agent_integration_incomplete');
+        const evidence = new Set(report.sources.map(source => source.path));
+        for (const path of [document.schemaPath, document.dataPath, document.platformI18nPath, 'package.json']) {
+            if (path && !evidence.has(path))
+                throw new ParameterAgentError('parameter_agent_evidence_missing');
+        }
+        for (const candidate of implemented) {
+            const field = catalog.find(entry => candidate.fieldPath && entry.key === candidate.fieldPath.join('.'));
+            if (!field || !field.editable || !field.canReset)
+                throw new ParameterAgentError('parameter_agent_field_not_ready');
+            if (field.hasOverride && validateParameterChange(document.schema, document.data, { fieldPath: field.fieldPath, value: field.value }))
+                throw new ParameterAgentError('parameter_agent_field_not_ready');
+            if (!candidate.consumers.length)
+                throw new ParameterAgentError('parameter_agent_consumer_missing');
+        }
+        const packageData = JSON.parse((await readParameterAgentFile(root, 'package.json')).toString('utf8'));
+        for (const script of ['test:parameters', 'build']) {
+            if (typeof packageData.scripts?.[script] !== 'string' || !packageData.scripts[script].trim())
+                throw new ParameterAgentError('parameter_agent_check_script_missing');
+        }
+        task.instanceToken = state.instanceToken;
+        await update(state, task, { status: 'checking', checks: [], error: undefined, receiptId: undefined, sourceDigest: before.digest }, root);
+        const scripts = ['test:parameters', 'build', ...(typeof packageData.scripts?.typecheck === 'string' ? ['typecheck'] : [])];
+        for (const script of scripts) {
+            assertActive();
+            const controller = new AbortController();
+            const abort = () => controller.abort();
+            options.signal?.addEventListener('abort', abort, { once: true });
+            let activityError;
+            const timer = setInterval(() => { try {
+                assertActive();
+            }
+            catch (error) {
+                activityError = error;
+                controller.abort();
+            } }, 200);
+            const startedAt = now();
+            const chunks = [];
+            let outputSize = 0;
+            let outcome;
+            try {
+                outcome = await (options.runCommand ?? runDeveloperCommand)(state, {
+                    processId: `parameter-check-${taskId}-${script.replace(':', '-')}`, cwd: root,
+                    command: `pnpm run ${script}`, timeoutMs: options.timeoutMs ?? 120_000, signal: controller.signal,
+                    onOutput(chunk) { const bytes = Buffer.from(chunk); outputSize += bytes.length; if (outputSize <= 1024 * 1024)
+                        chunks.push(bytes); },
+                });
+            }
+            finally {
+                clearInterval(timer);
+                options.signal?.removeEventListener('abort', abort);
+            }
+            if (activityError)
+                throw activityError;
+            assertActive();
+            task.record.checks.push({ script: script, code: outcome.code ?? null, timedOut: outcome.timedOut, ...(outcome.canceled ? { canceled: true } : {}), logDigest: parameterDigest(Buffer.concat(chunks)), startedAt, finishedAt: now() });
+            await writePrivateParameterTask(state, task, root);
+            if (outcome.code !== 0 || outcome.timedOut || outcome.canceled)
+                throw new ParameterAgentError(outcome.timedOut ? 'parameter_agent_check_timeout' : outcome.canceled ? 'parameter_agent_check_canceled' : 'parameter_agent_check_failed');
+        }
+        assertActive();
+        const after = await parameterInputSnapshot(root);
+        if (after.digest !== before.digest || parameterDigest(await readParameterAgentFile(root, task.record.reportPath, 1024 * 1024)) !== task.reportHash)
+            throw new ParameterAgentError('parameter_agent_inputs_changed');
+        return update(state, task, { status: 'verified', sourceDigest: after.digest, receiptId: randomUUID(), error: undefined }, root);
+    }
+    catch (cause) {
+        const code = errorCode(cause);
+        const status = code === 'ENOENT' ? 'missing' : /stale|changed|expired/.test(code) ? 'stale' : /(?:not_ready|incomplete|consumer_missing|script_missing|evidence_missing)$/.test(code) ? 'needs-verification' : /report_|evidence_invalid|path_invalid/.test(code) ? 'invalid' : 'failed';
+        return update(state, task, { status, error: code === 'ENOENT' ? 'parameter_agent_report_missing' : code, receiptId: undefined }, root);
+    }
+}

package/dist/workspace-runtime/workspaces/parameters.js

@@ -1,15 +1,40 @@
 import { readdir, readFile, realpath } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import { relative, resolve, sep } from 'node:path';
 import JSON5 from 'json5';
-import { parameterDocumentSchema, parameterPatchPayloadSchema, workspaceRelativePathSchema, WORKSPACE_FILE_CONTENT_MAX, } from '@playcraft/common/cloud-workspace/runtime';
+import { parameterDocumentSchema, parameterPatchPayloadSchema, validateParameterChange, workspaceRelativePathSchema, WORKSPACE_FILE_CONTENT_MAX, } from '@playcraft/common/cloud-workspace/runtime';
 import { InvalidWorkspacePathError, writeWorkspaceFile, } from './files.js';
-import { ParameterEditError, replaceJson5Path } from './json5-edit.js';
+import { editJson5Paths, ParameterEditError } from './json5-edit.js';
 const MANIFEST_PATH = '.playcraft/workspace.json';
 const DEFAULT_SCHEMA_PATH = 'src/theme/theme.schema.json5';
 const THEME_INDEX_PATH = 'src/theme/index.ts';
 const THEME_ROOT = 'src/theme';
 export async function readWorkspaceParameters(root, revisions) {
-    const located = await locateParameterFiles(root);
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const located = await locateParameterFiles(root);
+        const before = await sourceFingerprint(root, located);
+        const document = await readParameterDocuments(root, revisions, located);
+        const after = await sourceFingerprint(root, await locateParameterFiles(root));
+        if (before === after)
+            return parameterDocumentSchema.parse({ ...document, sourceFingerprint: after });
+    }
+    throw new ParameterEditError('parameter_source_changed');
+}
+async function sourceFingerprint(root, located) {
+    const sources = await Promise.all([
+        located.schemaPath ? readOptionalText(root, located.schemaPath) : undefined,
+        located.schemaPath ? readOptionalText(root, platformI18nPath(located.schemaPath)) : undefined,
+        readOptionalText(root, MANIFEST_PATH),
+        readOptionalText(root, THEME_INDEX_PATH),
+    ]);
+    return createHash('sha256').update(JSON.stringify({
+        schemaPath: located.schemaPath ?? null,
+        dataPath: located.dataPath ?? null,
+        themeId: located.themeId ?? null,
+        sources: sources.map((text) => text === undefined ? null : createHash('sha256').update(text).digest('hex')),
+    })).digest('hex');
+}
+async function readParameterDocuments(root, revisions, located) {
     if (located.errors.some((item) => item.reason === 'parameter_manifest_invalid')) {
         return parameterDocumentSchema.parse({ status: 'invalid', errors: located.errors });
     }
@@ -35,65 +60,88 @@ export async function readWorkspaceParameters(root, revisions) {
             errors: [{ path: located.schemaPath, reason: schemaFile.reason }],
         });
     }
+    const i18nPath = platformI18nPath(located.schemaPath);
+    const platformFile = await readOptionalJson5(root, i18nPath);
+    const schemaDocument = {
+        schemaPath: located.schemaPath,
+        themeId: located.themeId,
+        schema: schemaFile.value,
+        schemaHash: schemaFile.contentHash,
+        schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+        ...(platformFile.status === 'ok' ? { platformI18n: platformFile.value, platformI18nPath: i18nPath } : {}),
+    };
+    if (platformFile.status === 'invalid') {
+        return parameterDocumentSchema.parse({
+            ...schemaDocument,
+            status: 'invalid',
+            errors: [{ path: i18nPath, reason: platformFile.reason }],
+        });
+    }
     if (!located.dataPath) {
         return parameterDocumentSchema.parse({
+            ...schemaDocument,
             status: 'schema_only',
-            schemaPath: located.schemaPath,
-            themeId: located.themeId,
-            schema: schemaFile.value,
-            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
             ...(located.errors.length > 0 ? { errors: located.errors } : {}),
         });
     }
     const dataFile = await readOptionalJson5(root, located.dataPath);
     if (dataFile.status === 'missing') {
         return parameterDocumentSchema.parse({
+            ...schemaDocument,
             status: 'schema_only',
-            schemaPath: located.schemaPath,
             dataPath: located.dataPath,
-            themeId: located.themeId,
-            schema: schemaFile.value,
-            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
         });
     }
     if (dataFile.status === 'invalid') {
         return parameterDocumentSchema.parse({
+            ...schemaDocument,
             status: 'invalid',
-            schemaPath: located.schemaPath,
             dataPath: located.dataPath,
-            themeId: located.themeId,
-            schema: schemaFile.value,
-            schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
             errors: [{ path: located.dataPath, reason: dataFile.reason }],
         });
     }
     return parameterDocumentSchema.parse({
+        ...schemaDocument,
         status: 'ready',
-        schemaPath: located.schemaPath,
         dataPath: located.dataPath,
-        themeId: located.themeId,
-        schema: schemaFile.value,
         data: dataFile.value,
-        schemaRevision: revisions[located.schemaPath]?.revision ?? 0,
+        dataHash: dataFile.contentHash,
         dataRevision: revisions[located.dataPath]?.revision ?? 0,
     });
 }
-export async function patchWorkspaceParameters(root, revisions, payload) {
+export async function patchWorkspaceParameters(root, revisions, payload, observed) {
     const parsed = parameterPatchPayloadSchema.parse(payload);
     const document = await readWorkspaceParameters(root, revisions);
+    if (document.status === 'invalid')
+        throw new ParameterEditError('parameter_document_invalid');
     if (document.status === 'missing' || document.status === 'schema_only' || !document.dataPath) {
         throw new ParameterEditError('parameter_data_missing');
     }
-    if (document.status === 'invalid')
-        throw new ParameterEditError('parameter_document_invalid');
-    const typeError = validateAgainstSchema(document.schema, parsed.fieldPath, parsed.value);
-    if (typeError)
-        throw new ParameterEditError(typeError);
+    if ((parsed.sourceFingerprint && parsed.sourceFingerprint !== document.sourceFingerprint)
+        || (observed && observed.dataPath !== document.dataPath)) {
+        throw new ParameterEditError('parameter_source_conflict');
+    }
+    const changes = 'changes' in parsed ? parsed.changes : [{ fieldPath: parsed.fieldPath, value: parsed.value }];
+    for (const change of changes) {
+        const validationError = validateParameterChange(document.schema, document.data, change);
+        if (validationError)
+            throw new ParameterEditError(validationError);
+    }
     const source = await readOptionalText(root, document.dataPath);
     if (source === undefined)
         throw new ParameterEditError('parameter_data_missing');
-    const next = replaceJson5Path(source, parsed.fieldPath, parsed.value);
+    if (observed && createHash('sha256').update(source).digest('hex') !== observed.contentHash) {
+        throw new ParameterEditError('revision_conflict');
+    }
+    const next = editJson5Paths(source, changes);
     JSON5.parse(next);
+    if (Buffer.byteLength(next, 'utf8') > WORKSPACE_FILE_CONTENT_MAX) {
+        throw new ParameterEditError('parameter_document_invalid');
+    }
+    const current = await locateParameterFiles(root);
+    if (await sourceFingerprint(root, current) !== document.sourceFingerprint) {
+        throw new ParameterEditError('parameter_source_conflict');
+    }
     return writeWorkspaceFile(root, document.dataPath, next);
 }
 async function locateParameterFiles(root) {
@@ -210,7 +258,7 @@ async function readOptionalJson5(root, relativePath) {
     if (text === undefined)
         return { status: 'missing' };
     try {
-        return { status: 'ok', value: JSON5.parse(text) };
+        return { status: 'ok', value: JSON5.parse(text), contentHash: createHash('sha256').update(text).digest('hex') };
     }
     catch {
         return { status: 'invalid', reason: 'parameter_document_invalid' };
@@ -242,31 +290,6 @@ async function readOptionalText(root, relativePath) {
         throw error;
     }
 }
-function validateAgainstSchema(schema, fieldPath, value) {
-    let node = schema;
-    for (const key of fieldPath) {
-        if (!node || typeof node !== 'object' || Array.isArray(node))
-            return 'parameter_value_invalid';
-        const properties = node.properties;
-        if (!properties || typeof properties !== 'object' || Array.isArray(properties))
-            return 'parameter_value_invalid';
-        node = properties[key];
-        if (node === undefined)
-            return undefined;
-    }
-    if (!node || typeof node !== 'object' || Array.isArray(node))
-        return undefined;
-    const type = node.type;
-    if (type === 'string')
-        return typeof value === 'string' ? undefined : 'parameter_value_invalid';
-    if (type === 'boolean')
-        return typeof value === 'boolean' ? undefined : 'parameter_value_invalid';
-    if (type === 'integer')
-        return Number.isInteger(value) ? undefined : 'parameter_value_invalid';
-    if (type === 'number') {
-        return typeof value === 'number' && Number.isFinite(value) ? undefined : 'parameter_value_invalid';
-    }
-    if (type === 'null')
-        return value === null ? undefined : 'parameter_value_invalid';
-    return undefined;
+function platformI18nPath(schemaPath) {
+    return [...schemaPath.split('/').slice(0, -1), 'i18n.platform.json5'].join('/');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.48-beta",
+  "version": "0.1.50-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -51,8 +51,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "0.1.48-beta",
-    "@playcraft/common": "0.1.48-beta",
+    "@playcraft/build": "0.1.50-beta",
+    "@playcraft/common": "0.1.50-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",