@playcraft/cli 0.1.27 → 0.1.29

package/dist/video-replication/client.js

@@ -1,222 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, stat } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { videoAnalysisRequestSchema, videoAnalysisRunSchema, videoMediaInitResultSchema, videoMediaResultSchema, videoModelCatalogSchema, videoUnderstandingAnalysisSchema, } from '@playcraft/common/agent-tools';
-import { VideoCliError, videoMessage } from './messages.js';
-import { openVideo, verifyVideo } from './media.js';
-import { loadSavedRequest, prepareArtifactDirectory, writeJsonAtomic, } from './evidence.js';
-const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-export function requireVideoId(value) {
-    if (!uuid.test(value))
-        throw new VideoCliError('invalidArguments', 64);
-    return value.toLowerCase();
-}
-export async function resolveVideoWorkspace(explicit, cwd = process.cwd()) {
-    let context;
-    for (let path = resolve(cwd);; path = dirname(path)) {
-        try {
-            const file = join(path, '.playcraft/workspace-context.json');
-            if ((await stat(file)).size > 8192)
-                throw new VideoCliError('workspaceMissing', 64);
-            const value = JSON.parse(await readFile(file, 'utf8'));
-            if (value.schemaVersion !== 'playcraft.workspace-context.v1' || typeof value.workspaceId !== 'string')
-                throw new VideoCliError('workspaceMissing', 64);
-            context = requireVideoId(value.workspaceId);
-            break;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        if (dirname(path) === path)
-            break;
-    }
-    const workspace = explicit === undefined ? context : requireVideoId(explicit);
-    if (!workspace)
-        throw new VideoCliError('workspaceMissing', 64);
-    if (context && explicit && context !== workspace)
-        throw new VideoCliError('workspaceMismatch', 64);
-    return workspace;
-}
-export function parseVideoPolicy(options) {
-    const processing = options.processing ?? 'auto';
-    if (!['auto', 'agentic', 'static'].includes(processing))
-        throw new VideoCliError('invalidArguments', 64);
-    const fps = options.fps === undefined ? undefined : Number(options.fps);
-    if (fps !== undefined && ![1, 2, 4, 8].includes(fps))
-        throw new VideoCliError('invalidArguments', 64);
-    let clip;
-    if (options.clip !== undefined) {
-        if (!/^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(options.clip))
-            throw new VideoCliError('invalidArguments', 64);
-        const [startMs, endMs] = options.clip.split(':').map(value => Number(value) * 1000);
-        if (!Number.isFinite(endMs) || endMs <= startMs)
-            throw new VideoCliError('invalidArguments', 64);
-        clip = { startMs, endMs };
-    }
-    if (processing === 'agentic' && (fps !== undefined || clip))
-        throw new VideoCliError('invalidArguments', 64);
-    return { processing: processing, ...(fps !== undefined && { fps: fps }), ...(clip && { clip }) };
-}
-export function videoTimeout(options) {
-    const seconds = options.timeout === undefined ? 600 : Number(options.timeout);
-    if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 86_400)
-        throw new VideoCliError('invalidArguments', 64);
-    return seconds * 1000;
-}
-async function readContext(path, video) {
-    if (!path)
-        return undefined;
-    try {
-        if ((await stat(path)).size > 2 * 1024 * 1024)
-            throw new Error('large');
-        const analysis = videoUnderstandingAnalysisSchema.parse(JSON.parse(await readFile(path, 'utf8')));
-        if (analysis.source.sha256 !== video.source.sha256)
-            throw new Error('different video');
-        return analysis;
-    }
-    catch {
-        throw new VideoCliError('invalidContext', 64);
-    }
-}
-export async function uploadVideo(video, workspaceId, deps, signal) {
-    const mediaId = randomUUID();
-    const init = videoMediaInitResultSchema.parse(await deps.client.post('/video-media/init', {
-        workspaceId, mediaId, filename: basename(video.path), sha256: video.source.sha256,
-        sizeBytes: video.source.sizeBytes, mimeType: video.source.mimeType, contentMd5: video.contentMd5,
-    }, { signal }));
-    if (init.mediaId !== mediaId || Date.parse(init.upload.expiresAt) <= Date.now())
-        throw new VideoCliError('uploadFailed');
-    const file = await openVideo(video.path);
-    try {
-        await verifyVideo(file, video.source);
-        const stream = file.createReadStream({ start: 0, autoClose: false });
-        if (init.upload.authenticated) {
-            await deps.client.putVideoMedia(init.upload.url, stream, init.upload.headers, signal);
-        }
-        else {
-            const url = new URL(init.upload.url);
-            const allowed = new Set(['content-type', 'content-md5', 'content-length', 'x-cos-acl']);
-            if (url.protocol !== 'https:' || url.username || url.password || url.hash || Object.entries(init.upload.headers).some(([key, value]) => !allowed.has(key.toLowerCase()) || (key.toLowerCase() === 'x-cos-acl' && value !== 'private')))
-                throw new VideoCliError('uploadFailed');
-            const response = await fetch(url, { method: 'PUT', redirect: 'error', signal, headers: init.upload.headers, body: stream, duplex: 'half' });
-            if (!response.ok) {
-                await response.body?.cancel();
-                throw new VideoCliError('uploadFailed');
-            }
-            await response.body?.cancel();
-        }
-        await verifyVideo(file, video.source);
-    }
-    finally {
-        await file.close();
-    }
-    const finalized = videoMediaResultSchema.parse(await deps.client.post('/video-media/finalize', { workspaceId, mediaId }, { signal }));
-    if (finalized.mediaId !== mediaId || finalized.source.sha256 !== video.source.sha256 || finalized.source.sizeBytes !== video.source.sizeBytes)
-        throw new VideoCliError('sourceChanged');
-    return mediaId;
-}
-export async function readVideoRun(client, runId, workspaceId, signal) {
-    const run = videoAnalysisRunSchema.parse(await client.get(`/video-analysis/${runId}`, { workspaceId }, { signal }));
-    if (run.runId !== runId || run.workspaceId !== workspaceId || (run.analysis && run.analysis.runId !== runId))
-        throw new VideoCliError('invalidResult');
-    return run;
-}
-async function waitForVideoRun(run, deps, signal) {
-    while (['pending', 'uploading', 'submitting', 'running'].includes(run.state)) {
-        deps.progress('waiting');
-        await delay(Math.max(250, Math.min(run.pollAfterMs, 10_000)), undefined, { signal });
-        run = await readVideoRun(deps.client, run.runId, run.workspaceId, signal);
-    }
-    return run;
-}
-export async function executeVideoUnderstanding(options, signal, deps) {
-    let runId;
-    let out;
-    let saved;
-    let submitted = false;
-    try {
-        const workspaceId = await resolveVideoWorkspace(options.workspace);
-        const policy = parseVideoPolicy(options);
-        if (options.question !== undefined && (!options.question.trim() || options.question.length > 8000))
-            throw new VideoCliError('invalidArguments', 64);
-        if (options.resume && [options.video, options.question, options.context, options.processing, options.fps, options.clip, options.modelConfig].some(value => value !== undefined))
-            throw new VideoCliError('invalidArguments', 64);
-        if (!options.resume && !options.video)
-            throw new VideoCliError('invalidArguments', 64);
-        runId = options.resume ? requireVideoId(options.resume) : randomUUID();
-        out = resolve(options.out ?? join('.playcraft/video-replication', runId));
-        await prepareArtifactDirectory(out, runId, !!options.resume);
-        let run;
-        if (options.resume) {
-            saved = await loadSavedRequest(out, runId, workspaceId);
-            submitted = true;
-            // Recovery only reads the existing task. No upload or POST can be triggered here.
-            run = await readVideoRun(deps.client, runId, workspaceId, signal);
-            if (saved.request && run.mediaId !== saved.request.mediaId)
-                throw new VideoCliError('invalidResult');
-        }
-        else {
-            deps.progress('probing');
-            const video = await deps.probe(resolve(options.video), signal);
-            if (policy.clip && policy.clip.endMs > video.source.durationMs)
-                throw new VideoCliError('invalidArguments', 64);
-            const context = await readContext(options.context, video);
-            const catalog = videoModelCatalogSchema.parse(await deps.client.get('/video-models', { workspaceId }, { signal }));
-            const configId = options.modelConfig ? requireVideoId(options.modelConfig) : catalog.defaultConfigId;
-            const model = catalog.models.find(item => item.configId === configId);
-            const mode = policy.processing === 'auto'
-                ? policy.fps !== undefined || policy.clip || !model?.processing.includes('agentic') ? 'static' : 'agentic'
-                : policy.processing;
-            if (!model || !model.processing.includes(mode))
-                throw new VideoCliError('modelUnavailable', 64);
-            saved = { schemaVersion: 'playcraft.video-request.v1', runId, workspaceId, videoPath: video.path, out, state: 'uploading', createdAt: new Date().toISOString() };
-            await writeJsonAtomic(join(out, 'request.json'), saved);
-            deps.progress('uploading');
-            const mediaId = await uploadVideo(video, workspaceId, deps, signal);
-            const request = videoAnalysisRequestSchema.parse({
-                workspaceId, runId, mediaId, modelConfigId: configId, ...policy,
-                ...(options.question && { question: options.question }), ...(context && { context }),
-            });
-            saved = { ...saved, request, state: 'submitting' };
-            await writeJsonAtomic(join(out, 'request.json'), saved);
-            deps.progress('submitting');
-            submitted = true;
-            run = videoAnalysisRunSchema.parse(await deps.client.post('/video-analysis', request, {
-                signal,
-                onPrepared: async (operation) => {
-                    saved = { ...saved, requestId: operation.requestId };
-                    await writeJsonAtomic(join(out, 'request.json'), saved);
-                },
-            }));
-            if (run.runId !== runId || run.workspaceId !== workspaceId || run.mediaId !== mediaId)
-                throw new VideoCliError('invalidResult');
-        }
-        run = await waitForVideoRun(run, deps, signal);
-        await writeJsonAtomic(join(out, 'task.json'), run);
-        if (run.state === 'uncertain')
-            throw new VideoCliError('uncertain', 75);
-        if (run.state !== 'completed')
-            return {
-                exitCode: 4, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: run.state, ok: false, artifacts: { request: join(out, 'request.json') }, error: { code: run.error?.code ?? 'remoteFailed', message: videoMessage('remoteFailed') } },
-            };
-        if (!run.analysis || !saved || run.analysis.runId !== runId ||
-            (saved.request?.modelConfigId && run.analysis.model.configId !== saved.request.modelConfigId))
-            throw new VideoCliError('invalidResult');
-        deps.progress('extracting');
-        const artifacts = await deps.materialize({ analysis: run.analysis, sourcePath: saved.videoPath, out, request: saved.request, signal });
-        await writeJsonAtomic(join(out, 'request.json'), { ...saved, state: 'completed' });
-        return { exitCode: 0, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: 'completed', ok: true, artifacts } };
-    }
-    catch (error) {
-        const timeout = signal.aborted && signal.reason?.name === 'TimeoutError';
-        const interrupted = signal.aborted && !timeout;
-        const known = error instanceof VideoCliError;
-        const code = timeout ? 'timeoutReached' : interrupted ? 'interrupted' : known ? error.code : submitted ? 'uncertain' : 'failed';
-        const exitCode = timeout ? 75 : interrupted ? 130 : known ? error.exitCode : submitted ? 75 : 4;
-        if (saved && out && submitted && (exitCode === 75 || exitCode === 130))
-            await writeJsonAtomic(join(out, 'request.json'), { ...saved, state: 'uncertain' }).catch(() => { });
-        return { exitCode, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: exitCode === 75 || exitCode === 130 ? 'uncertain' : 'failed', ok: false, ...(saved && out && { artifacts: { request: join(out, 'request.json') } }), error: { code, message: videoMessage(code), ...(interrupted && { remoteCancellationConfirmed: false }) } } };
-    }
-}

package/dist/video-replication/comparison-evidence.js

@@ -1,149 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import sharp from 'sharp';
-import { replicaValidationResultSchema, validateReplicaComparisonContent, } from '@playcraft/common/agent-tools';
-import { openVideo, runMediaTool, verifyVideo } from './media.js';
-import { comparisonOutputPath, writeComparisonArtifact, writeComparisonJson } from './comparison-output.js';
-import { comparisonMessage as t, ComparisonCliError } from './comparison-messages.js';
-import { comparisonSha256 } from './comparison-files.js';
-const xml = (text) => text.replace(/[&<>"']/g, value => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[value]);
-const md = (text) => text.replace(/([\\`*_[\]<>])/g, '\\$1');
-const reasonMessages = {
-    'video.eventPairMissing': 'reasonEventPairMissing', 'video.dimensionUncertain': 'reasonDimensionUncertain',
-    'video.dimensionEventMissing': 'reasonDimensionEventMissing', 'video.progressionEvidenceMissing': 'reasonProgressionEvidenceMissing',
-    'video.timingPrecisionInsufficient': 'reasonTimingPrecisionInsufficient', 'video.timingFailureUnverified': 'reasonTimingFailureUnverified',
-    'video.requiredEffectsMissing': 'reasonRequiredEffectsMissing', 'video.controlRuntimeUncertain': 'reasonControlRuntimeUncertain',
-    'video.controlEvidenceMissing': 'reasonControlEvidenceMissing', 'video.requestsFailed': 'reasonRequestsFailed',
-};
-const renderReason = (reason) => {
-    const key = reason.startsWith('video.referenceKindMissing:') ? 'reasonReferenceKindMissing'
-        : Object.prototype.hasOwnProperty.call(reasonMessages, reason) ? reasonMessages[reason] : undefined;
-    return md(key ? `${t(key)} (${reason})` : reason);
-};
-async function tile(frame, out) {
-    const image = await sharp(join(out, frame.path)).resize(260, 190, { fit: 'contain', background: '#f4f4f4' }).png().toBuffer();
-    const label = Buffer.from(`<svg width="260" height="34"><rect width="100%" height="100%" fill="white"/><text x="8" y="14" font-size="11">${xml(frame.inputId)} · ${xml(frame.evidenceId)}</text><text x="8" y="29" font-size="11">${(frame.timeMs / 1000).toFixed(3)}s</text></svg>`);
-    return sharp({ create: { width: 260, height: 224, channels: 3, background: '#fff' } }).composite([{ input: image, top: 0, left: 0 }, { input: label, top: 190, left: 0 }]).png().toBuffer();
-}
-export function renderComparisonReport(comparison, frames) {
-    const frameMap = new Map(frames.map(frame => [frame.evidenceId, frame]));
-    const refs = (ids) => ids.map(id => `[${md(id)}](${frameMap.get(id)?.path})`).join(', ');
-    const list = (values) => values.length ? values.map(md).join(', ') : t('reportNone');
-    const timingStatus = comparison.timingChecks.some(check => check.status === 'fail') ? 'fail'
-        : !comparison.timingChecks.length || comparison.timingChecks.some(check => check.status === 'inconclusive') ? 'inconclusive' : 'pass';
-    const lines = [`# ${t('summary')}: ${comparison.status}`, '', t('coverageNotice'), '',
-        `## ${t('decision')}`, '', `- ${t('reportStatus')}: **${comparison.status}**`, `- ${t('reportScope')}: ${comparison.scope}`,
-        `- ${t('reportPolicy')}: ${comparison.policySha256}`, `- ${t('reportRecording')}: ${comparison.recordingHash}`, ''];
-    lines.push(t(comparison.status === 'pass' ? 'policyPassedNotice' : 'policyNotPassedNotice'), '', `## ${t('coverage')}`, '', t('deterministicNotice'), '', `- ${t('reportRequired')}: ${list(comparison.coverage.requiredEventIds)}`, `- ${t('reportEvaluated')}: ${list(comparison.coverage.evaluatedEventIds)}`, `- ${t('reportMissing')}: ${list(comparison.coverage.missingEventIds)}`, `- ${t('reportRequiredKinds')}: ${list(comparison.coverage.requiredKinds)}`, `- ${t('reportMissingKinds')}: ${list(comparison.coverage.missingKinds)}`, '', `### ${t('reportMissingEvidence')}`, '');
-    if (comparison.missingEvidence.some(item => item.dimension === 'interaction'))
-        lines.push(t('interactionUnverified'), '');
-    for (const item of comparison.missingEvidence)
-        lines.push(`- ${item.eventId ? `${md(item.eventId)}: ` : ''}${item.dimension ? `${item.dimension}: ` : ''}${renderReason(item.reason)}`);
-    if (!comparison.missingEvidence.length)
-        lines.push(`- ${t('reportNone')}`);
-    lines.push('', `### ${t('reportTimingChecks')}: ${timingStatus}`, '');
-    if (timingStatus === 'inconclusive')
-        lines.push(t('timingUnverified'), '');
-    for (const check of comparison.timingChecks)
-        lines.push(`- ${t('reportTiming')} ${md(check.eventId)} (${check.measurement}): ${check.status}; ${t('reportReference')} ${check.referenceRangeMs.join('–')} ms; ${t('reportCandidate')} ${check.candidateRangeMs.join('–')} ms; ${t('reportTolerance')} ${check.toleranceMs} ms`);
-    lines.push('', `## ${t('modelObservations')}`, '', t('modelObservationNotice'), '', `- ${t('reportModel')}: ${comparison.model.provider}/${comparison.model.model} (${comparison.model.processing})`, '', `### ${t('modelSummary')}`, '', md(comparison.summary), '', `### ${t('modelDimensions')}`, '');
-    for (const [dimension, judgment] of Object.entries(comparison.dimensions))
-        lines.push(`- **${dimension}: ${judgment.status}** (${judgment.confidence}) — ${md(judgment.reason)} ${refs(judgment.evidenceIds)}`);
-    lines.push('', `## ${t('differences')}`, '');
-    for (const finding of comparison.findings)
-        lines.push(`### ${md(finding.id)} · ${finding.severity} · ${finding.dimension}`, '', `- ${t('reportExpected')}: ${md(finding.expected)}`, `- ${t('reportObserved')}: ${md(finding.observed)}`, `- ${t('reportSuggestedFix')}: ${md(finding.suggestedFix)}`, `- ${t('reportConfidence')}: ${finding.confidence}; ${t('reportEvidence')}: ${refs(finding.evidenceIds)}`, '');
-    lines.push(`## ${t('alignment')}`, '');
-    for (const alignment of comparison.alignments) {
-        const reference = frameMap.get(alignment.referenceEvidenceId);
-        const candidate = frameMap.get(alignment.candidateEvidenceId);
-        lines.push(`- **${md(alignment.eventId)}** (${alignment.confidence}): ${t('reportReference')} ${reference?.timeMs} ms ↔ ${t('reportCandidate')} ${candidate?.timeMs} ms; ${refs([alignment.referenceEvidenceId, alignment.candidateEvidenceId])}`);
-    }
-    lines.push('', `## ${t('controls')}`, '');
-    for (const check of comparison.controlChecks)
-        lines.push(`- ${md(check.stepId)} → ${md(check.eventId)}; ${md(check.controlInputId)}: ${check.effect} (${check.confidence}); ${refs([check.candidateEvidenceId, check.controlEvidenceId])}`);
-    lines.push('', `## ${t('evidence')}`, '');
-    for (const frame of frames)
-        lines.push(`- ${md(frame.evidenceId)} · ${md(frame.inputId)}: ${t('reportRequested')} ${frame.requestedTimeMs} ms, ${t('reportDecoded')} ${frame.timeMs} ms; [${t('reportFrame')}](${frame.path})`);
-    return `${lines.join('\n')}\n`;
-}
-/** Extract real source frames for each validated input; model output never supplies local paths. */
-export async function materializeComparisonEvidence(input) {
-    let comparison;
-    try {
-        comparison = replicaValidationResultSchema.parse(input.comparison);
-        validateReplicaComparisonContent({ summary: comparison.summary, evidence: comparison.evidence, alignments: comparison.alignments,
-            dimensions: comparison.dimensions, findings: comparison.findings, controlChecks: comparison.controlChecks, timings: comparison.timings, missingEvidence: comparison.missingEvidence }, { inputs: comparison.inputs, analysis: input.request.analysis, recording: input.request.recording, policy: input.request.policy, processing: input.request.processing, fps: input.request.fps });
-    }
-    catch {
-        throw new ComparisonCliError('comparisonResult');
-    }
-    // Validate every destination before replacing any prior artifact.
-    for (const path of [...comparison.evidence.map(item => `keyframes/${item.inputId}/${item.id}.png`), 'comparison.json', 'comparison.md', 'manifest.json', 'contact-sheet.jpg', 'paired-contact-sheet.jpg'])
-        await comparisonOutputPath(input.out, path);
-    const frames = [];
-    for (const source of comparison.inputs) {
-        const local = input.inputs.find(item => item.id === source.id && item.role === source.role);
-        if (!local)
-            throw new ComparisonCliError('comparisonResult');
-        const evidence = comparison.evidence.filter(item => item.inputId === source.id);
-        if (!evidence.length)
-            continue;
-        const file = await openVideo(local.video.path);
-        try {
-            await verifyVideo(file, source.source);
-            const output = await runMediaTool('ffprobe', ['-v', 'error', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-                '-select_streams', 'v:0', '-show_entries', 'frame=best_effort_timestamp_time', '-of', 'csv=p=0', '/dev/fd/3'], file.fd, input.signal);
-            const raw = output.split('\n').map(line => Number.parseFloat(line) * 1000).filter(Number.isFinite);
-            const origin = raw[0] ?? 0;
-            const times = raw.map(time => time - origin).filter(time => time >= 0 && time < source.source.durationMs);
-            if (!times.length)
-                throw new ComparisonCliError('comparisonResult');
-            for (const item of evidence) {
-                input.signal?.throwIfAborted();
-                const requestedTimeMs = (item.startMs + item.endMs) / 2;
-                const timeMs = times.reduce((best, time) => Math.abs(time - requestedTimeMs) < Math.abs(best - requestedTimeMs) ? time : best);
-                const path = `keyframes/${source.id}/${item.id}.png`;
-                await writeComparisonArtifact(input.out, path, temporary => runMediaTool('ffmpeg', ['-v', 'error', '-nostdin', '-y', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-                    '-ss', (Math.max(0, timeMs - 0.01) / 1000).toFixed(6), '-i', '/dev/fd/3', '-map', '0:v:0', '-frames:v', '1',
-                    '-vf', 'scale=min(1280\\,iw):-2', '-threads', '1', temporary], file.fd, input.signal));
-                const bytes = await readFile(join(input.out, path));
-                const metadata = await sharp(bytes).metadata();
-                if (!metadata.width || !metadata.height)
-                    throw new ComparisonCliError('comparisonResult');
-                frames.push({ evidenceId: item.id, inputId: source.id, requestedTimeMs, timeMs, path, sha256: comparisonSha256(bytes) });
-            }
-            await verifyVideo(file, source.source);
-        }
-        finally {
-            await file.close();
-        }
-    }
-    if (frames.length !== comparison.evidence.length)
-        throw new ComparisonCliError('comparisonResult');
-    const tiles = await Promise.all(frames.map(frame => tile(frame, input.out)));
-    const columns = Math.min(4, tiles.length);
-    const contactSheet = join(input.out, 'contact-sheet.jpg');
-    await writeComparisonArtifact(input.out, 'contact-sheet.jpg', temporary => sharp({ create: { width: columns * 260, height: Math.ceil(tiles.length / columns) * 224, channels: 3, background: '#ddd' } })
-        .composite(tiles.map((value, index) => ({ input: value, left: index % columns * 260, top: Math.floor(index / columns) * 224 }))).jpeg({ quality: 85 }).toFile(temporary));
-    const pairs = comparison.alignments.flatMap(alignment => [alignment.referenceEvidenceId, alignment.candidateEvidenceId]);
-    const selected = pairs.length ? pairs.map(id => tiles[frames.findIndex(frame => frame.evidenceId === id)])
-        : ['reference', 'candidate'].flatMap(inputId => { const index = frames.findIndex(frame => frame.inputId === inputId); return index >= 0 ? [tiles[index]] : []; });
-    if (!selected.length)
-        throw new ComparisonCliError('comparisonResult');
-    const pairedContactSheet = join(input.out, 'paired-contact-sheet.jpg');
-    await writeComparisonArtifact(input.out, 'paired-contact-sheet.jpg', temporary => sharp({ create: { width: 520, height: Math.ceil(selected.length / 2) * 224, channels: 3, background: '#ddd' } })
-        .composite(selected.map((value, index) => ({ input: value, left: index % 2 * 260, top: Math.floor(index / 2) * 224 }))).jpeg({ quality: 85 }).toFile(temporary));
-    const resultPath = join(input.out, 'comparison.json');
-    const markdown = join(input.out, 'comparison.md');
-    await writeComparisonJson(input.out, 'comparison.json', comparison);
-    await writeComparisonArtifact(input.out, 'comparison.md', temporary => writeFile(temporary, renderComparisonReport(comparison, frames), { mode: 0o600, flag: 'wx' }));
-    const files = [];
-    for (const path of ['comparison.json', 'comparison.md', 'contact-sheet.jpg', 'paired-contact-sheet.jpg'])
-        files.push({ path, sha256: comparisonSha256(await readFile(join(input.out, path))) });
-    const manifest = join(input.out, 'manifest.json');
-    await writeComparisonJson(input.out, 'manifest.json', { schemaVersion: 'playcraft.replica-evidence.v1', runId: comparison.runId, state: 'completed', status: comparison.status,
-        recordingHash: comparison.recordingHash, policySha256: comparison.policySha256, model: comparison.model, inputs: comparison.inputs,
-        comparison: 'comparison.json', markdown: 'comparison.md', contactSheet: 'contact-sheet.jpg', pairedContactSheet: 'paired-contact-sheet.jpg',
-        files, frames, frameTimeSemantics: 'nearest-decoded-original-video-frame', audio: 'not_evaluated' });
-    return { manifest, comparison: resultPath, markdown, contactSheet, pairedContactSheet, keyframes: frames.map(frame => join(input.out, frame.path)) };
-}

package/dist/video-replication/comparison-files.js

@@ -1,57 +0,0 @@
-import { createHash } from 'node:crypto';
-import { lstat, open, realpath } from 'node:fs/promises';
-import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { ComparisonCliError } from './comparison-messages.js';
-export function comparisonSha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-export async function readComparisonJson(path, maxBytes = 2 * 1024 * 1024) {
-    const file = await open(path, 'r');
-    try {
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes)
-            throw new ComparisonCliError('invalidRecording', 64);
-        return JSON.parse(await file.readFile('utf8'));
-    }
-    finally {
-        await file.close();
-    }
-}
-/** Only recorder-owned, regular files under the exact recording directory may become evidence. */
-export async function recordingArtifactPath(root, path) {
-    if (!path || isAbsolute(path) || path.includes('\\') || path.split('/').some(part => !part || part === '.' || part === '..'))
-        throw new ComparisonCliError('invalidRecording', 64);
-    const base = await realpath(root);
-    const target = resolve(base, path);
-    const local = relative(base, target);
-    if (!local || local === '..' || local.startsWith(`..${sep}`) || isAbsolute(local))
-        throw new ComparisonCliError('invalidRecording', 64);
-    let current = base;
-    for (const part of local.split(sep)) {
-        current = resolve(current, part);
-        const stat = await lstat(current);
-        if (stat.isSymbolicLink())
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    if (await realpath(target) !== target || !(await lstat(target)).isFile())
-        throw new ComparisonCliError('invalidRecording', 64);
-    return target;
-}
-export async function verifyRecordingArtifact(root, artifact, maxBytes = 8 * 1024 * 1024) {
-    const path = await recordingArtifactPath(root, artifact.path);
-    const file = await open(path, 'r');
-    try {
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.size > maxBytes)
-            throw new ComparisonCliError('invalidRecording', 64);
-        const hash = createHash('sha256');
-        for await (const chunk of file.createReadStream({ autoClose: false, start: 0 }))
-            hash.update(chunk);
-        if (hash.digest('hex') !== artifact.sha256)
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    finally {
-        await file.close();
-    }
-    return path;
-}

package/dist/video-replication/comparison-log.js

@@ -1,72 +0,0 @@
-import { canonicalReplicaJson } from '@playcraft/common/agent-tools';
-import { ComparisonCliError } from './comparison-messages.js';
-/** Completed capture and every real/omitted scenario step must be represented in the hashed log. */
-export function validateComparisonInputLog(records, scenario, artifact) {
-    const invalid = () => { throw new ComparisonCliError('invalidRecording', 64); };
-    const finiteTime = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-    if (records.some(value => value === null || typeof value !== 'object' || Array.isArray(value)))
-        invalid();
-    const log = records;
-    const starts = log.filter(record => record.kind === 'recording-start'), ends = log.filter(record => record.kind === 'recording-end');
-    if (starts.length !== 1 || ends.length !== 1 || log[0] !== starts[0] || log.at(-1) !== ends[0])
-        invalid();
-    const start = starts[0], end = ends[0];
-    if (start.plannedAtMs !== 0 || start.actualAtMs !== 0 || start.device !== scenario.pointer || canonicalReplicaJson(start.reset) !== canonicalReplicaJson(scenario.reset)
-        || end.plannedAtMs !== scenario.durationMs || !finiteTime(end.actualAtMs) || end.actualAtMs < scenario.durationMs || end.status !== 'completed')
-        invalid();
-    if (log.some(record => record.status === 'failed' || !finiteTime(record.actualAtMs) || !finiteTime(record.plannedAtMs)))
-        invalid();
-    const finals = log.filter(record => ['tap', 'drag'].includes(String(record.kind)) && ['dispatched', 'omitted'].includes(String(record.status)));
-    if (finals.length !== scenario.steps.length)
-        invalid();
-    let previousEnd = -1;
-    for (const step of scenario.steps) {
-        const matching = finals.filter(record => record.stepId === step.id);
-        if (matching.length !== 1)
-            invalid();
-        const record = matching[0], omitted = artifact.omittedStepIds.includes(step.id);
-        if (record.kind !== step.type || record.plannedAtMs !== step.atMs || record.device !== scenario.pointer || record.status !== (omitted ? 'omitted' : 'dispatched')
-            || !finiteTime(record.actualAtMs) || record.actualAtMs + 2 < step.atMs || record.actualAtMs < previousEnd)
-            invalid();
-        const expected = (step.type === 'tap' ? [{ offsetMs: 0, x: step.x, y: step.y }] : step.path).map(point => ({ ...point, actual: {
-                x: (scenario.contentRect.x + point.x * scenario.contentRect.width) * scenario.viewport.width,
-                y: (scenario.contentRect.y + point.y * scenario.contentRect.height) * scenario.viewport.height,
-            } }));
-        if (canonicalReplicaJson(record.points) !== canonicalReplicaJson(expected))
-            invalid();
-        if (!omitted) {
-            if (!finiteTime(record.completedAtMs) || record.completedAtMs < record.actualAtMs
-                || record.completedAtMs > artifact.video.source.durationMs + artifact.timing.uncertaintyMs)
-                invalid();
-            const pointers = log.filter(pointer => pointer.stepId === step.id && pointer.kind === 'pointer' && pointer.status === 'dispatched');
-            if (step.type === 'tap' ? !pointers.some(pointer => pointer.phase === 'tap') : !['start', 'move', 'end'].every(phase => pointers.some(pointer => pointer.phase === phase)))
-                invalid();
-            previousEnd = record.completedAtMs;
-        }
-        else
-            previousEnd = record.actualAtMs;
-    }
-}
-/** Runtime counters must agree with the hashed console and browser event evidence. */
-export function validateComparisonConsoleLog(records, artifact) {
-    const counts = { pageErrors: 0, consoleErrors: 0, failedRequests: 0 };
-    for (const value of records) {
-        if (value === null || typeof value !== 'object' || Array.isArray(value))
-            throw new ComparisonCliError('invalidRecording', 64);
-        const record = value;
-        if (typeof record.atMs !== 'number' || !Number.isFinite(record.atMs) || record.atMs < 0)
-            throw new ComparisonCliError('invalidRecording', 64);
-        if (record.kind === 'console') {
-            if (record.level === 'error')
-                counts.consoleErrors++;
-        }
-        else if (['pageerror', 'popup', 'dialog'].includes(String(record.kind)))
-            counts.pageErrors++;
-        else if (record.kind === 'requestfailed')
-            counts.failedRequests++;
-        else
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    if (canonicalReplicaJson(counts) !== canonicalReplicaJson(artifact.runtime))
-        throw new ComparisonCliError('invalidRecording', 64);
-}

package/dist/video-replication/comparison-messages.js

@@ -1,104 +0,0 @@
-const messages = {
-    en: {
-        compare: 'Compare a recorded playable with its reference and extract paired evidence',
-        processing: 'static | agentic (defaults to static)',
-        reference: 'Original local reference video', analysis: 'Completed reference analysis.json',
-        candidate: 'Locally recorded candidate video', recording: 'Recording metadata.json with input and control evidence',
-        policy: 'Optional versioned comparison policy JSON', kind: 'understanding | comparison (defaults to understanding)',
-        invalidComparison: 'Comparison arguments or policy are invalid.',
-        unsafeOutput: 'The comparison output contains a linked or invalid directory or artifact. Choose a safe output directory.',
-        invalidRecording: 'Recording metadata, source hashes, input logs, or controls are invalid.',
-        staleRecording: 'The project changed after recording. Make a fresh recording before comparison.',
-        comparisonContext: 'The reference analysis does not match the reference video.',
-        comparisonResume: 'The saved comparison request is missing or does not match this run and workspace.',
-        comparisonUnavailable: 'No authorized model supports the requested comparison.',
-        comparisonResult: 'The comparison service returned invalid or incomplete evidence.',
-        comparisonFailed: 'Comparison failed. Inspect its saved request and task before retrying.',
-        summary: 'Comparison', decision: 'Policy decision', alignment: 'Model event alignment',
-        differences: 'Model-observed differences and modification suggestions', coverage: 'Coverage and uncertainty',
-        evidence: 'Paired evidence', controls: 'Model interpretation of interaction controls',
-        reportStatus: 'Result', reportRequiredKinds: 'Required event kinds', reportMissingKinds: 'Missing event kinds',
-        reportMissingEvidence: 'Missing or uncertain evidence', reportTimingChecks: 'Deterministic timing checks', reportNone: 'none',
-        modelObservations: 'Model observations', modelSummary: 'Model summary', modelDimensions: 'Model dimension judgments',
-        modelObservationNotice: 'These are model observations and interpretations. A model pass does not override the policy decision or missing evidence above.',
-        policyPassedNotice: 'Policy acceptance passed for this recorded scenario.',
-        policyNotPassedNotice: 'Policy acceptance has not passed. Gameplay equivalence has not been established.',
-        deterministicNotice: 'Coverage and timing checks below are deterministic. Missing evidence remains unverified even when a model observation says pass.',
-        interactionUnverified: 'Interaction is not fully verified: required causal or control evidence is missing or uncertain.',
-        timingUnverified: 'Timing is not fully verified: evidence precision or coverage is insufficient for the policy tolerance.',
-        reasonReferenceKindMissing: 'Reference analysis lacks a required event kind.',
-        reasonEventPairMissing: 'Reference and candidate lack a sufficiently confident event pair.',
-        reasonDimensionUncertain: 'The model judgment for this dimension is uncertain or below the required confidence.',
-        reasonDimensionEventMissing: 'This dimension does not cover a required event.',
-        reasonProgressionEvidenceMissing: 'Evidence for event progression timing is missing or insufficient.',
-        reasonTimingPrecisionInsufficient: 'Timing precision or coverage cannot resolve the policy tolerance.',
-        reasonTimingFailureUnverified: 'The model timing failure is not confirmed by deterministic timing checks.',
-        reasonRequiredEffectsMissing: 'Required gameplay results are not linked to recorded input steps.',
-        reasonControlRuntimeUncertain: 'A control recording contains runtime errors or failed requests.',
-        reasonControlEvidenceMissing: 'Required control evidence is missing, uncertain, or does not cover the candidate result window.',
-        reasonRequestsFailed: 'The candidate recording contains failed network requests.',
-        reportScope: 'Scope', reportModel: 'Model', reportPolicy: 'Policy', reportRecording: 'Recording',
-        reportExpected: 'Expected', reportObserved: 'Observed', reportSuggestedFix: 'Suggested fix',
-        reportConfidence: 'Confidence', reportEvidence: 'evidence', reportReference: 'reference', reportCandidate: 'candidate',
-        reportRequired: 'Required', reportEvaluated: 'Evaluated', reportMissing: 'Missing', reportTiming: 'Timing',
-        reportTolerance: 'tolerance', reportRequested: 'requested', reportDecoded: 'decoded', reportFrame: 'frame',
-        coverageNotice: 'This result covers only the recorded scenario. Audio and unshown gameplay branches were not evaluated.',
-    },
-    zh: {
-        compare: '比较复刻玩法录像与参考视频，并抽取成对证据',
-        processing: 'static | agentic，默认 static',
-        reference: '本地原始参考视频', analysis: '已完成的参考分析 analysis.json',
-        candidate: '本地录制的候选视频', recording: '包含输入和对照证据的录制 metadata.json',
-        policy: '可选的版本化比较策略 JSON', kind: 'understanding | comparison，默认 understanding',
-        invalidComparison: '比较参数或策略无效。',
-        unsafeOutput: '比较输出目录或制品包含符号链接或无效文件，请使用安全的输出目录。',
-        invalidRecording: '录制元数据、视频摘要、输入日志或对照证据无效。',
-        staleRecording: '工程在录制后发生了变化，请重新录制再比较。',
-        comparisonContext: '参考分析与参考视频不一致。',
-        comparisonResume: '比较请求不存在，或与任务、工作区不一致。',
-        comparisonUnavailable: '没有有权使用且支持所需比较模式的模型。',
-        comparisonResult: '比较服务返回的证据无效或不完整。',
-        comparisonFailed: '比较失败，请先核对已保存的请求和任务再重试。',
-        summary: '比较报告', decision: '策略结论', alignment: '模型事件配对',
-        differences: '模型观察到的差异和修改建议', coverage: '覆盖范围与未知项', evidence: '成对证据',
-        controls: '模型对交互对照的解释', coverageNotice: '结论仅覆盖本次录制场景；音频及未展示的玩法分支尚未评估。',
-        reportStatus: '结论', reportRequiredKinds: '必需事件类型', reportMissingKinds: '缺失事件类型',
-        reportMissingEvidence: '缺失或不确定的证据', reportTimingChecks: '确定性时序检查', reportNone: '无',
-        modelObservations: '模型观察', modelSummary: '模型摘要', modelDimensions: '模型维度判断',
-        modelObservationNotice: '以下内容是模型的观察和解释。模型判断为 pass，不会覆盖前面的策略结论或证据缺口。',
-        policyPassedNotice: '本次录制场景已通过策略验收。',
-        policyNotPassedNotice: '策略验收尚未通过，玩法等价性尚未得到验证。',
-        deterministicNotice: '以下覆盖范围和时序检查由确定性规则计算。即使模型判断为 pass，缺失证据的部分仍未得到验证。',
-        interactionUnverified: '交互尚未完整验证：必需的因果或对照证据缺失或不确定。',
-        timingUnverified: '时序尚未完整验证：证据精度或覆盖不足，无法满足策略容差。',
-        reasonReferenceKindMissing: '参考分析缺少必需的事件类型。',
-        reasonEventPairMissing: '参考视频与候选视频缺少达到置信度要求的事件配对。',
-        reasonDimensionUncertain: '模型对该维度的判断不确定，或未达到置信度要求。',
-        reasonDimensionEventMissing: '该维度尚未覆盖必需事件。',
-        reasonProgressionEvidenceMissing: '事件进展的时序证据缺失或不足。',
-        reasonTimingPrecisionInsufficient: '时序证据的精度或覆盖不足，无法按策略容差得出结论。',
-        reasonTimingFailureUnverified: '模型报告的时序失败尚未得到确定性时序检查的确认。',
-        reasonRequiredEffectsMissing: '必需的玩法结果尚未关联到录制输入步骤。',
-        reasonControlRuntimeUncertain: '对照录制存在运行错误或网络请求失败。',
-        reasonControlEvidenceMissing: '必需的对照证据缺失、不确定，或未覆盖候选结果的时间窗口。',
-        reasonRequestsFailed: '候选录制存在网络请求失败。',
-        reportScope: '范围', reportModel: '模型', reportPolicy: '策略', reportRecording: '录制',
-        reportExpected: '预期', reportObserved: '实际', reportSuggestedFix: '修改建议',
-        reportConfidence: '置信度', reportEvidence: '证据', reportReference: '参考', reportCandidate: '候选',
-        reportRequired: '必需', reportEvaluated: '已评估', reportMissing: '缺失', reportTiming: '时序',
-        reportTolerance: '容差', reportRequested: '请求时刻', reportDecoded: '解码时刻', reportFrame: '帧',
-    },
-};
-export function comparisonMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}
-export class ComparisonCliError extends Error {
-    code;
-    exitCode;
-    constructor(code, exitCode = 4) {
-        super(comparisonMessage(code));
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-}