codex-orchestrator 0.1.51 → 2.0.0

package/dist/src/v2/proof-report.js

@@ -0,0 +1,703 @@
+import { posix } from 'node:path';
+import { agentReportEnvelopeSchema } from './report-envelope.js';
+const MAX_STRING_LENGTH = 16 * 1024;
+const MAX_SUMMARY_LENGTH = 4 * 1024;
+const MAX_ARRAY_LENGTH = 256;
+const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+const SURFACES = ['non-visual', 'browser', 'android', 'ios'];
+const TARGETS = ['browser', 'android', 'ios'];
+const ARTIFACT_KINDS = [
+    'command-output', 'static-inspection', 'generated-file', 'screenshot',
+    'dom-snapshot', 'console-log', 'network-log', 'ui-hierarchy', 'device-log', 'lease-record',
+];
+export function validateProofReport(value) {
+    assertRecord(value, 'proof report');
+    const commonKeys = ['version', 'status', 'decision', 'criteria', 'checks', 'artifacts', 'findings', 'residualRisks'];
+    const visualReport = value.status !== 'external-block' && isRecord(value.decision) && value.decision.mode === 'visual';
+    if (value.status === 'passed' || value.status === 'needs-rework') {
+        assertExactObject(value, visualReport ? [...commonKeys, 'visualEvidence'] : commonKeys, 'proof report');
+    }
+    else if (value.status === 'external-block') {
+        assertExactObject(value, [...commonKeys, 'blocker'], 'proof report');
+    }
+    else {
+        throw new Error('proof report.status is invalid');
+    }
+    if (value.version !== 1)
+        throw new Error('proof report.version must be 1');
+    validateDecision(value.decision);
+    validateCriteria(value.criteria, value.status);
+    validateChecks(value.checks, value.status);
+    validateArtifacts(value.artifacts);
+    assertStringArray(value.findings, 'proof report.findings');
+    assertStringArray(value.residualRisks, 'proof report.residualRisks');
+    if (value.status === 'passed' && value.findings.length !== 0)
+        throw new Error('passed proof report forbids findings');
+    if (value.status === 'needs-rework' && value.findings.length === 0)
+        throw new Error('needs-rework proof report requires findings');
+    if (value.status === 'external-block')
+        validateExternalBlocker(value.blocker, 'proof report.blocker');
+    const decision = value.decision;
+    const criteria = value.criteria;
+    if (decision.mode === 'non-visual') {
+        if (criteria.some((criterion) => criterion.surfaces.some((surface) => surface !== 'non-visual'))) {
+            throw new Error('non-visual proof may use only non-visual criterion surfaces');
+        }
+    }
+    else {
+        const available = new Set(['non-visual', ...decision.targets]);
+        if (criteria.some((criterion) => criterion.surfaces.some((surface) => !available.has(surface)))) {
+            throw new Error('visual proof criterion surface is absent from decision targets');
+        }
+    }
+    if (visualReport) {
+        validateVisualEvidence(value.visualEvidence, criteria, value.artifacts, decision);
+    }
+    const evidenceIds = new Set([
+        ...value.checks.map((check) => check.id),
+        ...value.artifacts.map((artifact) => artifact.id),
+    ]);
+    for (const criterion of criteria) {
+        for (const ref of criterion.evidenceRefs) {
+            if (!evidenceIds.has(ref))
+                throw new Error(`criterion ${criterion.id} references unknown evidence ${ref}`);
+        }
+        if (value.status === 'passed' && criterion.evidenceRefs.length < criterion.surfaces.length) {
+            throw new Error(`passed criterion ${criterion.id} lacks evidence for every surface`);
+        }
+    }
+    return value;
+}
+export function createProofReceipt(input) {
+    assertBoundedString(input.proofId, 'proofId', MAX_STRING_LENGTH, true);
+    assertSha256(input.bindingSha256, 'bindingSha256');
+    assertBoundedString(input.summary, 'summary', MAX_SUMMARY_LENGTH, true);
+    assertBoundedString(input.localEvidenceId, 'localEvidenceId', MAX_STRING_LENGTH, true);
+    const report = validateProofReport(input.report);
+    return {
+        proofId: input.proofId,
+        bindingSha256: input.bindingSha256,
+        summary: input.summary,
+        publishableEvidence: report.artifacts
+            .filter((artifact) => artifact.publishable)
+            .map((artifact) => ({
+            ref: artifact.id,
+            kind: artifact.kind === 'screenshot' ? 'screenshot' : 'summary',
+            sha256: artifact.sha256,
+            description: artifact.description,
+        })),
+        localEvidenceId: input.localEvidenceId,
+    };
+}
+export function proofReportOutputSchema() {
+    return agentReportEnvelopeSchema({
+        type: 'object',
+        additionalProperties: false,
+        required: [
+            'version', 'status', 'decision', 'criteria', 'checks', 'artifacts',
+            'visualEvidence', 'findings', 'residualRisks', 'blocker',
+        ],
+        properties: {
+            version: { type: 'integer', const: 1 },
+            status: { type: 'string', enum: ['passed', 'needs-rework', 'external-block'] },
+            decision: decisionSchema(),
+            criteria: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: criterionSchema(false) },
+            checks: { type: 'array', maxItems: MAX_ARRAY_LENGTH, items: checkSchema(false) },
+            artifacts: { type: 'array', maxItems: MAX_ARRAY_LENGTH, items: artifactSchema() },
+            visualEvidence: {
+                anyOf: [browserVisualEvidenceSchema(), androidVisualEvidenceSchema(), iosVisualEvidenceSchema(), { type: 'null' }],
+            },
+            findings: stringArraySchema(),
+            residualRisks: stringArraySchema(),
+            blocker: { anyOf: [externalBlockerSchema(), { type: 'null' }] },
+        },
+    });
+}
+export function proofReportRepairDiagnostic(error) {
+    const detail = error instanceof Error ? error.message : 'unknown validation failure';
+    return `Return one complete JSON object matching the supplied proof output schema. Validation failed: ${detail}`;
+}
+export function proofReportSkillExcerpt() {
+    return 'Independently prove the frozen criteria and return only the JSON object required by the runner-supplied output schema. Do not edit product code, publish, or include credential/path material.';
+}
+function decisionSchema() {
+    return {
+        anyOf: [
+            nonVisualDecisionSchema(),
+            {
+                type: 'object',
+                additionalProperties: false,
+                required: ['mode', 'targets'],
+                properties: {
+                    mode: { type: 'string', const: 'visual' },
+                    targets: { type: 'array', minItems: 1, maxItems: TARGETS.length, items: { type: 'string', enum: TARGETS } },
+                },
+            },
+        ],
+    };
+}
+function nonVisualDecisionSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['mode', 'targets'],
+        properties: {
+            mode: { type: 'string', const: 'non-visual' },
+            targets: { type: 'array', maxItems: 0, items: { type: 'string', enum: TARGETS } },
+        },
+    };
+}
+function browserDecisionSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['mode', 'targets'],
+        properties: {
+            mode: { type: 'string', const: 'visual' },
+            targets: { type: 'array', minItems: 1, maxItems: 1, items: { type: 'string', const: 'browser' } },
+        },
+    };
+}
+function androidDecisionSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['mode', 'targets'],
+        properties: {
+            mode: { type: 'string', const: 'visual' },
+            targets: { type: 'array', minItems: 1, maxItems: 1, items: { type: 'string', const: 'android' } },
+        },
+    };
+}
+function iosDecisionSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['mode', 'targets'],
+        properties: {
+            mode: { type: 'string', const: 'visual' },
+            targets: { type: 'array', minItems: 1, maxItems: 1, items: { type: 'string', const: 'ios' } },
+        },
+    };
+}
+function criterionSchema(passed) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id', 'status', 'confidence', 'surfaces', 'evidenceRefs', 'analysis'],
+        properties: {
+            id: boundedStringSchema(MAX_STRING_LENGTH),
+            status: passed ? { type: 'string', const: 'passed' } : { type: 'string', enum: ['passed', 'failed', 'unknown'] },
+            confidence: passed ? { type: 'string', const: 'high' } : { type: 'string', enum: ['high', 'medium', 'low'] },
+            surfaces: { type: 'array', minItems: 1, maxItems: SURFACES.length, items: { type: 'string', enum: SURFACES } },
+            evidenceRefs: {
+                type: 'array',
+                minItems: passed ? 1 : 0,
+                maxItems: MAX_ARRAY_LENGTH,
+                items: boundedStringSchema(MAX_STRING_LENGTH),
+            },
+            analysis: boundedStringSchema(MAX_SUMMARY_LENGTH),
+        },
+    };
+}
+function checkSchema(passed) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id', 'command', 'status', 'summary', 'outputSha256'],
+        properties: {
+            id: boundedStringSchema(MAX_STRING_LENGTH),
+            command: boundedStringSchema(MAX_STRING_LENGTH),
+            status: passed ? { type: 'string', const: 'passed' } : { type: 'string', enum: ['passed', 'failed'] },
+            summary: boundedStringSchema(MAX_SUMMARY_LENGTH),
+            outputSha256: sha256Schema(),
+        },
+    };
+}
+function artifactSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id', 'kind', 'relativePath', 'sha256', 'publishable', 'description'],
+        properties: {
+            id: boundedStringSchema(MAX_STRING_LENGTH),
+            kind: { type: 'string', enum: ARTIFACT_KINDS },
+            relativePath: relativePathSchema(),
+            sha256: sha256Schema(),
+            publishable: { type: 'boolean' },
+            description: boundedStringSchema(MAX_SUMMARY_LENGTH),
+        },
+    };
+}
+function browserVisualEvidenceSchema() {
+    const reviewSchema = {
+        type: 'array',
+        minItems: 1,
+        maxItems: MAX_ARRAY_LENGTH,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['summary', 'evidenceRefs'],
+            properties: {
+                summary: boundedStringSchema(MAX_SUMMARY_LENGTH),
+                evidenceRefs: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+            },
+        },
+    };
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['workflow', 'captures', 'diagnostics', 'freshness', 'layoutReview', 'copyReview'],
+        properties: {
+            workflow: {
+                type: 'object', additionalProperties: false, required: ['entrypoint', 'steps', 'finalState'],
+                properties: {
+                    entrypoint: boundedStringSchema(MAX_STRING_LENGTH),
+                    steps: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+                    finalState: boundedStringSchema(MAX_SUMMARY_LENGTH),
+                },
+            },
+            captures: {
+                type: 'array', minItems: 2, maxItems: MAX_ARRAY_LENGTH,
+                items: {
+                    type: 'object', additionalProperties: false,
+                    required: ['target', 'name', 'width', 'height', 'criteriaRefs', 'screenshotRef', 'stateRef'],
+                    properties: {
+                        target: { type: 'string', const: 'browser' },
+                        name: boundedStringSchema(MAX_STRING_LENGTH),
+                        width: { type: 'integer' },
+                        height: { type: 'integer' },
+                        criteriaRefs: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+                        screenshotRef: boundedStringSchema(MAX_STRING_LENGTH),
+                        stateRef: boundedStringSchema(MAX_STRING_LENGTH),
+                    },
+                },
+            },
+            diagnostics: {
+                type: 'object', additionalProperties: false, required: ['consoleRef', 'networkRef'],
+                properties: { consoleRef: boundedStringSchema(MAX_STRING_LENGTH), networkRef: boundedStringSchema(MAX_STRING_LENGTH) },
+            },
+            freshness: {
+                type: 'object', additionalProperties: false, required: ['capturedAfterFinalInteraction'],
+                properties: { capturedAfterFinalInteraction: { type: 'boolean', const: true } },
+            },
+            layoutReview: reviewSchema,
+            copyReview: reviewSchema,
+        },
+    };
+}
+function androidVisualEvidenceSchema() {
+    return mobileVisualEvidenceSchema('android');
+}
+function iosVisualEvidenceSchema() {
+    return mobileVisualEvidenceSchema('ios');
+}
+function mobileVisualEvidenceSchema(target) {
+    const reviewSchema = {
+        type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH,
+        items: {
+            type: 'object', additionalProperties: false, required: ['summary', 'evidenceRefs'],
+            properties: {
+                summary: boundedStringSchema(MAX_SUMMARY_LENGTH),
+                evidenceRefs: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+            },
+        },
+    };
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['workflow', 'captures', 'diagnostics', 'lease', 'freshness', 'layoutReview', 'copyReview'],
+        properties: {
+            workflow: {
+                type: 'object', additionalProperties: false, required: ['entrypoint', 'steps', 'finalState'],
+                properties: {
+                    entrypoint: boundedStringSchema(MAX_STRING_LENGTH),
+                    steps: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+                    finalState: boundedStringSchema(MAX_SUMMARY_LENGTH),
+                },
+            },
+            captures: {
+                type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH,
+                items: {
+                    type: 'object', additionalProperties: false,
+                    required: ['target', 'name', 'width', 'height', 'criteriaRefs', 'screenshotRef', 'stateRef'],
+                    properties: {
+                        target: { type: 'string', const: target },
+                        name: boundedStringSchema(MAX_STRING_LENGTH),
+                        width: { type: 'integer' },
+                        height: { type: 'integer' },
+                        criteriaRefs: { type: 'array', minItems: 1, maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) },
+                        screenshotRef: boundedStringSchema(MAX_STRING_LENGTH),
+                        stateRef: boundedStringSchema(MAX_STRING_LENGTH),
+                    },
+                },
+            },
+            diagnostics: {
+                type: 'object', additionalProperties: false, required: ['deviceLogRef'],
+                properties: { deviceLogRef: boundedStringSchema(MAX_STRING_LENGTH) },
+            },
+            lease: {
+                type: 'object', additionalProperties: false, required: ['leaseRef'],
+                properties: { leaseRef: boundedStringSchema(MAX_STRING_LENGTH) },
+            },
+            freshness: {
+                type: 'object', additionalProperties: false, required: ['capturedAfterFinalInteraction'],
+                properties: { capturedAfterFinalInteraction: { type: 'boolean', const: true } },
+            },
+            layoutReview: reviewSchema,
+            copyReview: reviewSchema,
+        },
+    };
+}
+function validateDecision(value) {
+    assertExactObject(value, ['mode', 'targets'], 'proof report.decision');
+    if (value.mode !== 'non-visual' && value.mode !== 'visual')
+        throw new Error('proof report.decision.mode is invalid');
+    assertEnumArray(value.targets, TARGETS, 'proof report.decision.targets');
+    if (value.mode === 'non-visual' && value.targets.length !== 0)
+        throw new Error('non-visual decision forbids targets');
+    if (value.mode === 'visual' && value.targets.length === 0)
+        throw new Error('visual decision requires targets');
+}
+function validateCriteria(value, reportStatus) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > MAX_ARRAY_LENGTH) {
+        throw new Error('proof report.criteria must contain 1 to 256 entries');
+    }
+    const ids = [];
+    for (const [index, criterion] of value.entries()) {
+        const field = `proof report.criteria[${index}]`;
+        assertExactObject(criterion, ['id', 'status', 'confidence', 'surfaces', 'evidenceRefs', 'analysis'], field);
+        assertBoundedString(criterion.id, `${field}.id`, MAX_STRING_LENGTH, true);
+        if (!['passed', 'failed', 'unknown'].includes(criterion.status))
+            throw new Error(`${field}.status is invalid`);
+        if (!['high', 'medium', 'low'].includes(criterion.confidence))
+            throw new Error(`${field}.confidence is invalid`);
+        assertEnumArray(criterion.surfaces, SURFACES, `${field}.surfaces`, true);
+        assertStringArray(criterion.evidenceRefs, `${field}.evidenceRefs`);
+        assertUnique(criterion.evidenceRefs, `${field}.evidenceRefs`);
+        assertBoundedString(criterion.analysis, `${field}.analysis`, MAX_SUMMARY_LENGTH, true);
+        if (reportStatus === 'passed' && (criterion.status !== 'passed' || criterion.confidence !== 'high')) {
+            throw new Error('passed proof requires every criterion passed with high confidence');
+        }
+        if (reportStatus === 'passed' && criterion.evidenceRefs.length === 0) {
+            throw new Error('passed proof requires criterion evidence');
+        }
+        ids.push(criterion.id);
+    }
+    assertUnique(ids, 'proof report.criteria ids');
+}
+function validateChecks(value, reportStatus) {
+    if (!Array.isArray(value) || value.length > MAX_ARRAY_LENGTH)
+        throw new Error('proof report.checks must contain at most 256 entries');
+    const ids = [];
+    for (const [index, check] of value.entries()) {
+        const field = `proof report.checks[${index}]`;
+        assertExactObject(check, ['id', 'command', 'status', 'summary', 'outputSha256'], field);
+        assertBoundedString(check.id, `${field}.id`, MAX_STRING_LENGTH, true);
+        assertBoundedString(check.command, `${field}.command`, MAX_STRING_LENGTH, true);
+        if (check.status !== 'passed' && check.status !== 'failed')
+            throw new Error(`${field}.status is invalid`);
+        if (reportStatus === 'passed' && check.status !== 'passed')
+            throw new Error('passed proof forbids failed checks');
+        assertBoundedString(check.summary, `${field}.summary`, MAX_SUMMARY_LENGTH, true);
+        assertSha256(check.outputSha256, `${field}.outputSha256`);
+        ids.push(check.id);
+    }
+    assertUnique(ids, 'proof report.check ids');
+}
+function validateArtifacts(value) {
+    if (!Array.isArray(value) || value.length > MAX_ARRAY_LENGTH)
+        throw new Error('proof report.artifacts must contain at most 256 entries');
+    const ids = [];
+    for (const [index, artifact] of value.entries()) {
+        const field = `proof report.artifacts[${index}]`;
+        assertExactObject(artifact, ['id', 'kind', 'relativePath', 'sha256', 'publishable', 'description'], field);
+        assertBoundedString(artifact.id, `${field}.id`, MAX_STRING_LENGTH, true);
+        if (!ARTIFACT_KINDS.includes(artifact.kind)) {
+            throw new Error(`${field}.kind is invalid`);
+        }
+        assertRelativePath(artifact.relativePath, `${field}.relativePath`);
+        assertSha256(artifact.sha256, `${field}.sha256`);
+        if (typeof artifact.publishable !== 'boolean')
+            throw new Error(`${field}.publishable must be boolean`);
+        if (artifact.publishable && artifact.kind !== 'screenshot' && artifact.kind !== 'generated-file') {
+            throw new Error('only screenshots or sanitized generated summaries may be publishable');
+        }
+        if (['dom-snapshot', 'console-log', 'network-log', 'ui-hierarchy', 'device-log', 'lease-record'].includes(artifact.kind)
+            && artifact.publishable !== false) {
+            throw new Error(`${field}.kind must remain local-only`);
+        }
+        assertBoundedString(artifact.description, `${field}.description`, MAX_SUMMARY_LENGTH, true);
+        ids.push(artifact.id);
+    }
+    assertUnique(ids, 'proof report.artifact ids');
+}
+function validateVisualEvidence(value, criteria, artifacts, decision) {
+    if (decision.targets.length !== 1)
+        throw new Error('visual proof requires one settled platform target');
+    if (decision.targets[0] === 'browser')
+        return validateBrowserVisualEvidence(value, criteria, artifacts, decision);
+    if (decision.targets[0] === 'android')
+        return validateAndroidVisualEvidence(value, criteria, artifacts, decision);
+    if (decision.targets[0] === 'ios')
+        return validateIosVisualEvidence(value, criteria, artifacts, decision);
+    throw new Error('visual proof target is not implemented');
+}
+function validateBrowserVisualEvidence(value, criteria, artifacts, decision) {
+    if (decision.targets.length !== 1 || decision.targets[0] !== 'browser') {
+        throw new Error('Spec 3 visual proof supports the browser target only');
+    }
+    assertExactObject(value, ['workflow', 'captures', 'diagnostics', 'freshness', 'layoutReview', 'copyReview'], 'proof report.visualEvidence');
+    assertExactObject(value.workflow, ['entrypoint', 'steps', 'finalState'], 'proof report.visualEvidence.workflow');
+    assertBoundedString(value.workflow.entrypoint, 'proof report.visualEvidence.workflow.entrypoint', MAX_STRING_LENGTH, true);
+    if (!/^https?:\/\//u.test(value.workflow.entrypoint))
+        throw new Error('visual workflow entrypoint must be HTTP(S)');
+    assertStringArray(value.workflow.steps, 'proof report.visualEvidence.workflow.steps');
+    if (value.workflow.steps.length === 0)
+        throw new Error('visual workflow requires steps');
+    assertBoundedString(value.workflow.finalState, 'proof report.visualEvidence.workflow.finalState', MAX_SUMMARY_LENGTH, true);
+    const artifactById = new Map(artifacts.map((artifact) => [artifact.id, artifact]));
+    const browserCriteria = criteria.filter((criterion) => criterion.surfaces.includes('browser'));
+    const browserCriterionIds = new Set(browserCriteria.map((criterion) => criterion.id));
+    if (browserCriteria.length === 0)
+        throw new Error('browser decision requires a browser criterion surface');
+    if (!Array.isArray(value.captures) || value.captures.length < 2 || value.captures.length > MAX_ARRAY_LENGTH) {
+        throw new Error('browser visual evidence requires at least two captures');
+    }
+    const captureNames = [];
+    for (const [index, capture] of value.captures.entries()) {
+        const field = `proof report.visualEvidence.captures[${index}]`;
+        assertExactObject(capture, ['target', 'name', 'width', 'height', 'criteriaRefs', 'screenshotRef', 'stateRef'], field);
+        if (capture.target !== 'browser')
+            throw new Error(`${field}.target must be browser`);
+        assertBoundedString(capture.name, `${field}.name`, MAX_STRING_LENGTH, true);
+        if (!Number.isSafeInteger(capture.width) || !Number.isSafeInteger(capture.height)
+            || capture.width < 1 || capture.height < 1
+            || capture.width > 10_000 || capture.height > 10_000) {
+            throw new Error(`${field} dimensions are invalid`);
+        }
+        assertStringArray(capture.criteriaRefs, `${field}.criteriaRefs`);
+        assertUnique(capture.criteriaRefs, `${field}.criteriaRefs`);
+        if (capture.criteriaRefs.length === 0 || capture.criteriaRefs.some((id) => !browserCriterionIds.has(id))) {
+            throw new Error(`${field} has irrelevant criterion mapping`);
+        }
+        for (const criterionId of browserCriterionIds) {
+            if (!capture.criteriaRefs.includes(criterionId))
+                throw new Error(`${field} omits browser criterion ${criterionId}`);
+        }
+        assertBoundedString(capture.screenshotRef, `${field}.screenshotRef`, MAX_STRING_LENGTH, true);
+        assertBoundedString(capture.stateRef, `${field}.stateRef`, MAX_STRING_LENGTH, true);
+        const screenshot = artifactById.get(capture.screenshotRef);
+        const state = artifactById.get(capture.stateRef);
+        if (screenshot?.kind !== 'screenshot')
+            throw new Error(`${field} lacks screenshot evidence`);
+        if (state?.kind !== 'dom-snapshot')
+            throw new Error(`${field} lacks DOM state evidence`);
+        for (const criterionId of capture.criteriaRefs) {
+            const criterion = browserCriteria.find((candidate) => candidate.id === criterionId);
+            if (!criterion.evidenceRefs.includes(screenshot.id) || !criterion.evidenceRefs.includes(state.id)) {
+                throw new Error(`${field} evidence is not linked to criterion ${criterionId}`);
+            }
+        }
+        captureNames.push(capture.name);
+    }
+    assertUnique(captureNames, 'proof report.visualEvidence capture names');
+    if (!value.captures.some((capture) => capture.width >= 1024)) {
+        throw new Error('browser visual evidence lacks desktop coverage');
+    }
+    if (!value.captures.some((capture) => capture.width <= 480)) {
+        throw new Error('browser visual evidence lacks narrow responsive coverage');
+    }
+    assertExactObject(value.diagnostics, ['consoleRef', 'networkRef'], 'proof report.visualEvidence.diagnostics');
+    if (artifactById.get(value.diagnostics.consoleRef)?.kind !== 'console-log') {
+        throw new Error('browser visual evidence lacks console diagnostics');
+    }
+    if (artifactById.get(value.diagnostics.networkRef)?.kind !== 'network-log') {
+        throw new Error('browser visual evidence lacks network diagnostics');
+    }
+    assertExactObject(value.freshness, ['capturedAfterFinalInteraction'], 'proof report.visualEvidence.freshness');
+    if (value.freshness.capturedAfterFinalInteraction !== true)
+        throw new Error('browser evidence is not post-interaction');
+    validateVisualReview(value.layoutReview, 'layoutReview', artifactById);
+    validateVisualReview(value.copyReview, 'copyReview', artifactById);
+}
+function validateAndroidVisualEvidence(value, criteria, artifacts, decision) {
+    validateMobileVisualEvidence(value, criteria, artifacts, decision, 'android');
+}
+function validateIosVisualEvidence(value, criteria, artifacts, decision) {
+    validateMobileVisualEvidence(value, criteria, artifacts, decision, 'ios');
+}
+function validateMobileVisualEvidence(value, criteria, artifacts, decision, target) {
+    if (decision.targets.length !== 1 || decision.targets[0] !== target)
+        throw new Error(`${target} visual target mismatch`);
+    assertExactObject(value, ['workflow', 'captures', 'diagnostics', 'lease', 'freshness', 'layoutReview', 'copyReview'], 'proof report.visualEvidence');
+    assertExactObject(value.workflow, ['entrypoint', 'steps', 'finalState'], 'proof report.visualEvidence.workflow');
+    assertBoundedString(value.workflow.entrypoint, 'proof report.visualEvidence.workflow.entrypoint', MAX_STRING_LENGTH, true);
+    assertStringArray(value.workflow.steps, 'proof report.visualEvidence.workflow.steps');
+    if (value.workflow.steps.length === 0)
+        throw new Error(`${target} visual workflow requires steps`);
+    assertBoundedString(value.workflow.finalState, 'proof report.visualEvidence.workflow.finalState', MAX_SUMMARY_LENGTH, true);
+    const artifactById = new Map(artifacts.map((artifact) => [artifact.id, artifact]));
+    const androidCriteria = criteria.filter((criterion) => criterion.surfaces.includes(target));
+    const androidCriterionIds = new Set(androidCriteria.map((criterion) => criterion.id));
+    if (androidCriteria.length === 0)
+        throw new Error(`${target} decision requires a ${target} criterion surface`);
+    if (!Array.isArray(value.captures) || value.captures.length === 0 || value.captures.length > MAX_ARRAY_LENGTH) {
+        throw new Error(`${target} visual evidence requires a capture`);
+    }
+    const captureNames = [];
+    for (const [index, capture] of value.captures.entries()) {
+        const field = `proof report.visualEvidence.captures[${index}]`;
+        assertExactObject(capture, ['target', 'name', 'width', 'height', 'criteriaRefs', 'screenshotRef', 'stateRef'], field);
+        if (capture.target !== target)
+            throw new Error(`${field}.target must be ${target}`);
+        assertBoundedString(capture.name, `${field}.name`, MAX_STRING_LENGTH, true);
+        if (!Number.isSafeInteger(capture.width) || !Number.isSafeInteger(capture.height)
+            || capture.width < 1 || capture.height < 1
+            || capture.width > 10_000 || capture.height > 10_000) {
+            throw new Error(`${field} dimensions are invalid`);
+        }
+        assertStringArray(capture.criteriaRefs, `${field}.criteriaRefs`);
+        assertUnique(capture.criteriaRefs, `${field}.criteriaRefs`);
+        if (capture.criteriaRefs.length === 0 || capture.criteriaRefs.some((id) => !androidCriterionIds.has(id))) {
+            throw new Error(`${field} has irrelevant criterion mapping`);
+        }
+        for (const criterionId of androidCriterionIds) {
+            if (!capture.criteriaRefs.includes(criterionId))
+                throw new Error(`${field} omits ${target} criterion ${criterionId}`);
+        }
+        assertBoundedString(capture.screenshotRef, `${field}.screenshotRef`, MAX_STRING_LENGTH, true);
+        assertBoundedString(capture.stateRef, `${field}.stateRef`, MAX_STRING_LENGTH, true);
+        const screenshot = artifactById.get(capture.screenshotRef);
+        const hierarchy = artifactById.get(capture.stateRef);
+        if (screenshot?.kind !== 'screenshot')
+            throw new Error(`${field} lacks screenshot evidence`);
+        if (hierarchy?.kind !== 'ui-hierarchy')
+            throw new Error(`${field} lacks UI hierarchy evidence`);
+        for (const criterionId of capture.criteriaRefs) {
+            const criterion = androidCriteria.find((candidate) => candidate.id === criterionId);
+            if (!criterion.evidenceRefs.includes(screenshot.id) || !criterion.evidenceRefs.includes(hierarchy.id)) {
+                throw new Error(`${field} evidence is not linked to criterion ${criterionId}`);
+            }
+        }
+        captureNames.push(capture.name);
+    }
+    assertUnique(captureNames, 'proof report.visualEvidence capture names');
+    assertExactObject(value.diagnostics, ['deviceLogRef'], 'proof report.visualEvidence.diagnostics');
+    if (artifactById.get(value.diagnostics.deviceLogRef)?.kind !== 'device-log') {
+        throw new Error(`${target} visual evidence lacks device log diagnostics`);
+    }
+    assertExactObject(value.lease, ['leaseRef'], 'proof report.visualEvidence.lease');
+    if (artifactById.get(value.lease.leaseRef)?.kind !== 'lease-record') {
+        throw new Error(`${target} visual evidence lacks lease record`);
+    }
+    assertExactObject(value.freshness, ['capturedAfterFinalInteraction'], 'proof report.visualEvidence.freshness');
+    if (value.freshness.capturedAfterFinalInteraction !== true)
+        throw new Error(`${target} evidence is not post-interaction`);
+    validateVisualReview(value.layoutReview, 'layoutReview', artifactById);
+    validateVisualReview(value.copyReview, 'copyReview', artifactById);
+}
+function validateVisualReview(value, fieldName, artifactById) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > MAX_ARRAY_LENGTH) {
+        throw new Error(`proof report.visualEvidence.${fieldName} must be non-empty`);
+    }
+    for (const [index, finding] of value.entries()) {
+        const field = `proof report.visualEvidence.${fieldName}[${index}]`;
+        assertExactObject(finding, ['summary', 'evidenceRefs'], field);
+        assertBoundedString(finding.summary, `${field}.summary`, MAX_SUMMARY_LENGTH, true);
+        assertStringArray(finding.evidenceRefs, `${field}.evidenceRefs`);
+        assertUnique(finding.evidenceRefs, `${field}.evidenceRefs`);
+        if (finding.evidenceRefs.length === 0 || finding.evidenceRefs.some((ref) => !artifactById.has(ref))) {
+            throw new Error(`${field} has invalid evidence references`);
+        }
+    }
+}
+function validateExternalBlocker(value, field) {
+    assertExactObject(value, ['kind', 'summary', 'attempted'], field);
+    if (!['credential', 'tool', 'service', 'product-decision'].includes(value.kind))
+        throw new Error(`${field}.kind is invalid`);
+    assertBoundedString(value.summary, `${field}.summary`, MAX_SUMMARY_LENGTH, true);
+    assertStringArray(value.attempted, `${field}.attempted`);
+}
+function externalBlockerSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['kind', 'summary', 'attempted'],
+        properties: {
+            kind: { type: 'string', enum: ['credential', 'tool', 'service', 'product-decision'] },
+            summary: boundedStringSchema(MAX_SUMMARY_LENGTH),
+            attempted: stringArraySchema(),
+        },
+    };
+}
+function stringArraySchema() {
+    return { type: 'array', maxItems: MAX_ARRAY_LENGTH, items: boundedStringSchema(MAX_STRING_LENGTH) };
+}
+function boundedStringSchema(maxLength) {
+    return { type: 'string', minLength: 1, maxLength };
+}
+function sha256Schema() {
+    return { type: 'string', pattern: '^[0-9a-f]{64}$' };
+}
+function relativePathSchema() {
+    return {
+        type: 'string',
+        minLength: 1,
+        maxLength: MAX_STRING_LENGTH,
+        pattern: '^[^/\\\\]$|^[^/\\\\][^\\\\]*[^/\\\\]$',
+    };
+}
+function assertRelativePath(value, field) {
+    assertBoundedString(value, field, MAX_STRING_LENGTH, true);
+    if (value.startsWith('/') || value.includes('\\') || posix.normalize(value) !== value) {
+        throw new Error(`${field} must be a normalized repository-relative POSIX path`);
+    }
+    const segments = value.split('/');
+    if (segments.some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        throw new Error(`${field} must not contain empty, dot, or dot-dot segments`);
+    }
+}
+function assertEnumArray(value, allowed, field, requireNonEmpty = false) {
+    if (!Array.isArray(value) || value.length > MAX_ARRAY_LENGTH || (requireNonEmpty && value.length === 0)) {
+        throw new Error(`${field} has invalid length`);
+    }
+    if (value.some((item) => typeof item !== 'string' || !allowed.includes(item)))
+        throw new Error(`${field} has invalid entries`);
+    assertUnique(value, field);
+}
+function assertStringArray(value, field) {
+    if (!Array.isArray(value) || value.length > MAX_ARRAY_LENGTH)
+        throw new Error(`${field} must contain at most 256 strings`);
+    for (const item of value)
+        assertBoundedString(item, `${field} entry`, MAX_STRING_LENGTH, true);
+}
+function assertUnique(values, field) {
+    if (new Set(values).size !== values.length)
+        throw new Error(`${field} must be unique`);
+}
+function assertSha256(value, field) {
+    if (typeof value !== 'string' || !SHA256_PATTERN.test(value))
+        throw new Error(`${field} must be lowercase SHA-256`);
+}
+function assertBoundedString(value, field, maxLength, requireNonEmpty) {
+    if (typeof value !== 'string' || value.length > maxLength || (requireNonEmpty && value.length === 0)) {
+        throw new Error(`${field} must be a bounded string`);
+    }
+}
+function assertRecord(value, field) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`${field} must be an object`);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertExactObject(value, keys, field) {
+    assertRecord(value, field);
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+        throw new Error(`${field} has unknown or missing keys`);
+    }
+}
+//# sourceMappingURL=proof-report.js.map