project-tiny-context-harness 0.7.8 → 0.8.0

package/dist/lib/design-resource-handoff-shape-structure.js

@@ -0,0 +1,118 @@
+import { contractKey, contractKeys, designResourceShapeFail, positiveInteger, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
+const SHA256 = /^[a-f0-9]{64}$/u;
+export function parseDesignResourceHandoffResources(value) {
+    return array(value, "design_resource_handoff.resources").map((item, index) => {
+        const label = `design_resource_handoff.resources[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "role",
+            "path",
+            "media_type",
+            "sha256",
+            "editable_upstream",
+        ]);
+        const upstream = object(row.editable_upstream, `${label}.editable_upstream`, ["owner", "locator", "update_route"]);
+        const digest = string(row.sha256, `${label}.sha256`);
+        if (!SHA256.test(digest))
+            designResourceShapeFail(`${label}.sha256`, "must be a lowercase SHA-256");
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            role: literal(row.role, ["exact_target", "constraint", "supporting"], `${label}.role`),
+            path: repositoryFile(row.path, `${label}.path`),
+            media_type: string(row.media_type, `${label}.media_type`),
+            sha256: digest,
+            editable_upstream: {
+                owner: string(upstream.owner, `${label}.editable_upstream.owner`),
+                locator: string(upstream.locator, `${label}.editable_upstream.locator`),
+                update_route: string(upstream.update_route, `${label}.editable_upstream.update_route`),
+            },
+        };
+    });
+}
+export function parseDesignResourceHandoffConditions(value) {
+    return array(value, "design_resource_handoff.conditions").map((item, index) => {
+        const label = `design_resource_handoff.conditions[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "platform",
+            "viewport",
+            "modes",
+            "states",
+            "content_cases",
+            "input_methods",
+            "motion",
+        ]);
+        const viewport = object(row.viewport, `${label}.viewport`, [
+            "width",
+            "height",
+            "unit",
+        ]);
+        return {
+            key: contractKey(row.key, `${label}.key`),
+            platform: string(row.platform, `${label}.platform`),
+            viewport: {
+                width: positiveInteger(viewport.width, `${label}.viewport.width`),
+                height: positiveInteger(viewport.height, `${label}.viewport.height`),
+                unit: literal(viewport.unit, ["px"], `${label}.viewport.unit`),
+            },
+            modes: strings(row.modes, `${label}.modes`),
+            states: strings(row.states, `${label}.states`),
+            content_cases: strings(row.content_cases, `${label}.content_cases`),
+            input_methods: strings(row.input_methods, `${label}.input_methods`),
+            motion: literal(row.motion, ["full", "reduced", "not_applicable"], `${label}.motion`),
+        };
+    });
+}
+export function parseDesignResourceHandoffSubjects(value) {
+    return array(value, "design_resource_handoff.subjects").map((item, index) => {
+        const label = `design_resource_handoff.subjects[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "kind",
+            "stable_keys",
+            "target_refs",
+        ]);
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            kind: literal(row.kind, [
+                "surface",
+                "flow",
+                "region",
+                "component_family",
+                "control",
+                "state",
+                "asset",
+            ], `${label}.kind`),
+            stable_keys: stableKeys(row.stable_keys, `${label}.stable_keys`),
+            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
+        };
+    });
+}
+export function parseDesignResourceHandoffTargets(value) {
+    return array(value, "design_resource_handoff.targets").map((item, index) => {
+        const label = `design_resource_handoff.targets[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "interpretation",
+            "resource_refs",
+            "condition_refs",
+            "source_profile",
+            "selection_basis",
+        ]);
+        const sourceProfile = object(row.source_profile, `${label}.source_profile`, ["kind", "entry_resource_ref", "dependency_resource_refs", "acquisition"]);
+        return {
+            key: contractKey(row.key, `${label}.key`),
+            interpretation: literal(row.interpretation, ["exact_target", "constraint"], `${label}.interpretation`),
+            resource_refs: stableKeys(row.resource_refs, `${label}.resource_refs`),
+            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
+            source_profile: {
+                kind: literal(sourceProfile.kind, ["implementation_web", "implementation_app", "reference"], `${label}.source_profile.kind`),
+                entry_resource_ref: stableKey(sourceProfile.entry_resource_ref, `${label}.source_profile.entry_resource_ref`),
+                dependency_resource_refs: stableKeys(sourceProfile.dependency_resource_refs, `${label}.source_profile.dependency_resource_refs`),
+                acquisition: literal(sourceProfile.acquisition, ["complete"], `${label}.source_profile.acquisition`),
+            },
+            selection_basis: string(row.selection_basis, `${label}.selection_basis`),
+        };
+    });
+}

package/dist/lib/design-resource-handoff-shape.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function parseDesignResourceHandoffShape(value: unknown): DesignResourceHandoffV1;

package/dist/lib/design-resource-handoff-shape.js

@@ -0,0 +1,75 @@
+import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, } from "./design-resource-handoff-shape-evidence.js";
+import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { parseDesignResourceHandoffConditions, parseDesignResourceHandoffResources, parseDesignResourceHandoffSubjects, parseDesignResourceHandoffTargets, } from "./design-resource-handoff-shape-structure.js";
+import { literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceHandoffShape(value) {
+    const root = object(value, "design_resource_handoff", [
+        "schema_version",
+        "intent",
+        "scope",
+        "provenance",
+        "resources",
+        "conditions",
+        "subjects",
+        "targets",
+        "evidence",
+        "coverage",
+        "acceptance_blockers",
+        "proposal",
+    ]);
+    const scope = object(root.scope, "design_resource_handoff.scope", [
+        "key",
+        "style_dependency",
+        "surface_keys",
+        "necessary_context",
+        "exclusions",
+    ]);
+    const provenance = object(root.provenance, "design_resource_handoff.provenance", [
+        "provider",
+        "provider_version",
+        "project",
+        "run",
+        "capability",
+        "agent",
+        "model",
+        "design_system_id",
+    ]);
+    const proposal = object(root.proposal, "design_resource_handoff.proposal", [
+        "reconciliation_status",
+        "path",
+        "revision",
+    ]);
+    return {
+        schema_version: literal(root.schema_version, ["design-resource-handoff-v1"], "design_resource_handoff.schema_version"),
+        intent: literal(root.intent, ["implementation_handoff"], "design_resource_handoff.intent"),
+        scope: {
+            key: contractKey(scope.key, "design_resource_handoff.scope.key"),
+            style_dependency: literal(scope.style_dependency, ["style-bearing", "non-fidelity", "mixed"], "design_resource_handoff.scope.style_dependency"),
+            surface_keys: stableKeys(scope.surface_keys, "design_resource_handoff.scope.surface_keys"),
+            necessary_context: strings(scope.necessary_context, "design_resource_handoff.scope.necessary_context"),
+            exclusions: strings(scope.exclusions, "design_resource_handoff.scope.exclusions"),
+        },
+        provenance: {
+            provider: string(provenance.provider, "design_resource_handoff.provenance.provider"),
+            provider_version: string(provenance.provider_version, "design_resource_handoff.provenance.provider_version"),
+            project: string(provenance.project, "design_resource_handoff.provenance.project"),
+            run: string(provenance.run, "design_resource_handoff.provenance.run"),
+            capability: string(provenance.capability, "design_resource_handoff.provenance.capability"),
+            agent: string(provenance.agent, "design_resource_handoff.provenance.agent"),
+            model: string(provenance.model, "design_resource_handoff.provenance.model"),
+            design_system_id: string(provenance.design_system_id, "design_resource_handoff.provenance.design_system_id"),
+        },
+        resources: parseDesignResourceHandoffResources(root.resources),
+        conditions: parseDesignResourceHandoffConditions(root.conditions),
+        subjects: parseDesignResourceHandoffSubjects(root.subjects),
+        targets: parseDesignResourceHandoffTargets(root.targets),
+        evidence: parseDesignResourceHandoffEvidence(root.evidence),
+        coverage: parseDesignResourceHandoffCoverage(root.coverage),
+        acceptance_blockers: parseDesignResourceHandoffBlockers(root.acceptance_blockers),
+        proposal: {
+            reconciliation_status: literal(proposal.reconciliation_status, ["applied", "returned", "not_applicable"], "design_resource_handoff.proposal.reconciliation_status"),
+            path: repositoryFile(proposal.path, "design_resource_handoff.proposal.path"),
+            revision: string(proposal.revision, "design_resource_handoff.proposal.revision"),
+        },
+    };
+}

package/dist/lib/design-resource-handoff-types.d.ts

@@ -0,0 +1,139 @@
+export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
+export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
+export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation"];
+export type DesignResourceEvidenceKind = (typeof DESIGN_RESOURCE_EVIDENCE_KINDS)[number];
+export declare const DESIGN_RESOURCE_VERIFICATION_METHODS: readonly ["layout_geometry", "visual_pixel", "design_token", "content", "component_state", "interaction_trace", "motion_timeline", "responsive_reflow", "input_method", "accessibility_semantics", "asset_integrity"];
+export type DesignResourceVerificationMethod = (typeof DESIGN_RESOURCE_VERIFICATION_METHODS)[number];
+export declare const DESIGN_RESOURCE_LOCATOR_KINDS: readonly ["html_selector", "markdown_anchor", "json_pointer", "css_selector", "css_custom_property", "whole_resource"];
+export type DesignResourceLocatorKind = (typeof DESIGN_RESOURCE_LOCATOR_KINDS)[number];
+export type DesignResourceSourceProfileKind = "implementation_web" | "implementation_app" | "reference";
+export type DesignResourceCoverageDisposition = "covered" | "not_applicable" | "excluded_by_scope" | "decision_required" | "unavailable";
+export interface DesignResourceHandoffV1 {
+    schema_version: "design-resource-handoff-v1";
+    intent: "implementation_handoff";
+    scope: {
+        key: string;
+        style_dependency: "style-bearing" | "non-fidelity" | "mixed";
+        surface_keys: string[];
+        necessary_context: string[];
+        exclusions: string[];
+    };
+    provenance: {
+        provider: string;
+        provider_version: string;
+        project: string;
+        run: string;
+        capability: string;
+        agent: string;
+        model: string;
+        design_system_id: string;
+    };
+    resources: DesignResourceHandoffResourceV1[];
+    conditions: DesignResourceHandoffConditionV1[];
+    subjects: DesignResourceHandoffSubjectV1[];
+    targets: DesignResourceHandoffTargetV1[];
+    evidence: DesignResourceHandoffEvidenceV1[];
+    coverage: DesignResourceHandoffCoverageV1[];
+    acceptance_blockers: DesignResourceHandoffBlockerV1[];
+    proposal: {
+        reconciliation_status: "applied" | "returned" | "not_applicable";
+        path: string;
+        revision: string;
+    };
+}
+export interface DesignResourceHandoffResourceV1 {
+    key: string;
+    role: "exact_target" | "constraint" | "supporting";
+    path: string;
+    media_type: string;
+    sha256: string;
+    editable_upstream: {
+        owner: string;
+        locator: string;
+        update_route: string;
+    };
+}
+export interface DesignResourceHandoffConditionV1 {
+    key: string;
+    platform: string;
+    viewport: {
+        width: number;
+        height: number;
+        unit: "px";
+    };
+    modes: string[];
+    states: string[];
+    content_cases: string[];
+    input_methods: string[];
+    motion: "full" | "reduced" | "not_applicable";
+}
+export interface DesignResourceHandoffSubjectV1 {
+    key: string;
+    kind: "surface" | "flow" | "region" | "component_family" | "control" | "state" | "asset";
+    stable_keys: string[];
+    target_refs: string[];
+}
+export interface DesignResourceHandoffTargetV1 {
+    key: string;
+    interpretation: "exact_target" | "constraint";
+    resource_refs: string[];
+    condition_refs: string[];
+    source_profile: {
+        kind: DesignResourceSourceProfileKind;
+        entry_resource_ref: string;
+        dependency_resource_refs: string[];
+        acquisition: "complete";
+    };
+    selection_basis: string;
+}
+export interface DesignResourceHandoffEvidenceV1 {
+    key: string;
+    resource_ref: string;
+    kind: DesignResourceEvidenceKind;
+    locator: {
+        kind: DesignResourceLocatorKind;
+        value: string;
+    };
+    condition_refs: string[];
+}
+export interface DesignResourceHandoffCoverageV1 {
+    key: string;
+    subject_refs: string[];
+    dimension: DesignResourceDimension;
+    disposition: DesignResourceCoverageDisposition;
+    target_refs: string[];
+    condition_refs: string[];
+    evidence_refs: string[];
+    source_item_refs: string[];
+    verification_methods: DesignResourceVerificationMethod[];
+    rationale: string;
+}
+export interface DesignResourceHandoffBlockerV1 {
+    key: string;
+    target_refs: string[];
+    subject_refs: string[];
+    dimensions: DesignResourceDimension[];
+    source_item_refs: string[];
+    verification_methods: DesignResourceVerificationMethod[];
+    description: string;
+}
+export interface ParsedDesignResourceHandoffV1 {
+    handoff_path: string;
+    handoff: DesignResourceHandoffV1;
+    source_item_keys: string[];
+    source_item_kinds: Record<string, string>;
+}
+export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHandoffV1 {
+    schema_version: "design-resource-handoff-preflight-v1";
+    status: "ready";
+    resource_hashes: Record<string, string>;
+    counts: {
+        resources: number;
+        conditions: number;
+        subjects: number;
+        targets: number;
+        evidence: number;
+        coverage: number;
+        acceptance_blockers: number;
+    };
+}

package/dist/lib/design-resource-handoff-types.js

@@ -0,0 +1,46 @@
+export const DESIGN_RESOURCE_DIMENSIONS = [
+    "surface_flow",
+    "visual_content",
+    "component_control",
+    "state_interaction",
+    "motion",
+    "adaptation_input",
+    "accessibility",
+    "assets",
+];
+export const DESIGN_RESOURCE_EVIDENCE_KINDS = [
+    "frame",
+    "component_variant",
+    "prototype_state",
+    "prototype_transition",
+    "motion_spec",
+    "motion_capture",
+    "responsive_spec",
+    "input_spec",
+    "accessibility_spec",
+    "semantic_tree",
+    "token_spec",
+    "asset",
+    "annotation",
+];
+export const DESIGN_RESOURCE_VERIFICATION_METHODS = [
+    "layout_geometry",
+    "visual_pixel",
+    "design_token",
+    "content",
+    "component_state",
+    "interaction_trace",
+    "motion_timeline",
+    "responsive_reflow",
+    "input_method",
+    "accessibility_semantics",
+    "asset_integrity",
+];
+export const DESIGN_RESOURCE_LOCATOR_KINDS = [
+    "html_selector",
+    "markdown_anchor",
+    "json_pointer",
+    "css_selector",
+    "css_custom_property",
+    "whole_resource",
+];

package/dist/lib/design-resource-handoff-validation-coverage.d.ts

@@ -0,0 +1,4 @@
+import { type DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceCoverage(handoff: DesignResourceHandoffV1, subjects: Map<string, unknown>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, conditions: Map<string, unknown>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>, sourceItems: Map<string, string>): void;
+export declare function validateDesignResourceBlockers(handoff: DesignResourceHandoffV1, subjects: Map<string, unknown>, targets: Map<string, unknown>, sourceItems: Map<string, string>): void;
+export declare function validateDesignResourceReachability(handoff: DesignResourceHandoffV1): void;

package/dist/lib/design-resource-handoff-validation-coverage.js

@@ -0,0 +1,168 @@
+import { DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
+import { DESIGN_RESOURCE_DIMENSIONS, } from "./design-resource-handoff-types.js";
+import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, sourceItems) {
+    const cells = new Set();
+    const unresolved = [];
+    for (const row of handoff.coverage) {
+        requireNonemptyDesignResourceValues(row.subject_refs, `coverage_subject_refs_required:${row.key}`);
+        requireNonemptyDesignResourceValues(row.source_item_refs, `coverage_source_item_refs_required:${row.key}`);
+        for (const [name, values] of [
+            ["subject_ref", row.subject_refs],
+            ["target_ref", row.target_refs],
+            ["condition_ref", row.condition_refs],
+            ["evidence_ref", row.evidence_refs],
+            ["source_item_ref", row.source_item_refs],
+            ["verification_method", row.verification_methods],
+        ])
+            requireUniqueDesignResourceValues(values, `coverage_${name}_duplicate:${row.key}`);
+        for (const ref of row.subject_refs)
+            requireKnownDesignResourceRef(subjects, ref, "subject");
+        for (const ref of row.source_item_refs) {
+            requireKnownDesignResourceRef(sourceItems, ref, "source_item");
+            requireDesignSourceItemKind(sourceItems, ref);
+        }
+        validateCoverageApplicability(row, handoff, targets, conditions, cells);
+        if (row.disposition === "covered")
+            validateCoveredRow(row, targets, conditions, evidence);
+        else
+            validateNoncoveredRow(row);
+        if (row.disposition === "decision_required" ||
+            row.disposition === "unavailable")
+            unresolved.push(row.key);
+    }
+    for (const subject of handoff.subjects)
+        for (const targetRef of subject.target_refs) {
+            const target = targets.get(targetRef);
+            for (const conditionRef of target.condition_refs)
+                for (const dimension of DESIGN_RESOURCE_DIMENSIONS) {
+                    const cell = coverageCell(subject.key, targetRef, conditionRef, dimension);
+                    if (!cells.has(cell))
+                        invalidDesignResourceHandoff("coverage_cell_missing", `${subject.key}:${targetRef}:${conditionRef}:${dimension}`);
+                }
+        }
+    if (unresolved.length)
+        invalidDesignResourceHandoff("unresolved_coverage", unresolved.sort().join(","));
+}
+function validateCoverageApplicability(row, handoff, targets, conditions, cells) {
+    requireNonemptyDesignResourceValues(row.target_refs, `coverage_target_refs_required:${row.key}`);
+    requireNonemptyDesignResourceValues(row.condition_refs, `coverage_condition_refs_required:${row.key}`);
+    for (const targetRef of row.target_refs)
+        requireKnownDesignResourceRef(targets, targetRef, "target");
+    for (const conditionRef of row.condition_refs)
+        requireKnownDesignResourceRef(conditions, conditionRef, "condition");
+    const subjects = new Map(handoff.subjects.map((item) => [item.key, item]));
+    for (const subjectRef of row.subject_refs) {
+        const subject = subjects.get(subjectRef);
+        for (const targetRef of row.target_refs) {
+            if (!subject.target_refs.includes(targetRef))
+                invalidDesignResourceHandoff("coverage_target_outside_subject", `${row.key}:${subjectRef}:${targetRef}`);
+            const target = targets.get(targetRef);
+            for (const conditionRef of row.condition_refs) {
+                if (!target.condition_refs.includes(conditionRef))
+                    invalidDesignResourceHandoff("coverage_condition_outside_target", `${row.key}:${targetRef}:${conditionRef}`);
+                const cell = coverageCell(subjectRef, targetRef, conditionRef, row.dimension);
+                if (cells.has(cell))
+                    invalidDesignResourceHandoff("coverage_cell_duplicate", `${subjectRef}:${targetRef}:${conditionRef}:${row.dimension}`);
+                cells.add(cell);
+            }
+        }
+    }
+}
+function coverageCell(subjectRef, targetRef, conditionRef, dimension) {
+    return `${subjectRef}\0${targetRef}\0${conditionRef}\0${dimension}`;
+}
+export function validateDesignResourceBlockers(handoff, subjects, targets, sourceItems) {
+    for (const blocker of handoff.acceptance_blockers) {
+        for (const [name, values] of [
+            ["target_refs", blocker.target_refs],
+            ["subject_refs", blocker.subject_refs],
+            ["dimensions", blocker.dimensions],
+            ["source_item_refs", blocker.source_item_refs],
+            ["verification_methods", blocker.verification_methods],
+        ]) {
+            requireNonemptyDesignResourceValues(values, `acceptance_blocker_${name}_required:${blocker.key}`);
+            requireUniqueDesignResourceValues(values, `acceptance_blocker_${name}_duplicate:${blocker.key}`);
+        }
+        for (const ref of blocker.target_refs)
+            requireKnownDesignResourceRef(targets, ref, "target");
+        for (const ref of blocker.subject_refs)
+            requireKnownDesignResourceRef(subjects, ref, "subject");
+        for (const ref of blocker.source_item_refs) {
+            requireKnownDesignResourceRef(sourceItems, ref, "source_item");
+            requireDesignSourceItemKind(sourceItems, ref);
+        }
+        for (const dimension of blocker.dimensions)
+            if (!blocker.verification_methods.some((method) => DESIGN_RESOURCE_METHODS_BY_DIMENSION[dimension].includes(method)))
+                invalidDesignResourceHandoff("acceptance_blocker_dimension_method_missing", `${blocker.key}:${dimension}`);
+        const matchedCoverage = handoff.coverage.filter((row) => row.disposition === "covered" &&
+            blocker.target_refs.some((ref) => row.target_refs.includes(ref)) &&
+            blocker.subject_refs.some((ref) => row.subject_refs.includes(ref)) &&
+            blocker.dimensions.includes(row.dimension));
+        for (const ref of blocker.source_item_refs)
+            if (!matchedCoverage.some((row) => row.source_item_refs.includes(ref)))
+                invalidDesignResourceHandoff("acceptance_blocker_source_item_without_coverage", `${blocker.key}:${ref}`);
+        for (const method of blocker.verification_methods)
+            if (!matchedCoverage.some((row) => row.verification_methods.includes(method)))
+                invalidDesignResourceHandoff("acceptance_blocker_method_without_coverage", `${blocker.key}:${method}`);
+    }
+}
+export function validateDesignResourceReachability(handoff) {
+    const targetResources = new Set(handoff.targets.flatMap((target) => target.resource_refs));
+    const targetConditions = new Set(handoff.targets.flatMap((target) => target.condition_refs));
+    const coverageTargets = new Set(handoff.coverage.flatMap((row) => row.target_refs));
+    const coverageEvidence = new Set(handoff.coverage.flatMap((row) => row.evidence_refs));
+    for (const resource of handoff.resources)
+        if (!targetResources.has(resource.key))
+            invalidDesignResourceHandoff("resource_unreferenced", resource.key);
+    for (const condition of handoff.conditions)
+        if (!targetConditions.has(condition.key))
+            invalidDesignResourceHandoff("condition_unreferenced", condition.key);
+    for (const target of handoff.targets)
+        if (!coverageTargets.has(target.key))
+            invalidDesignResourceHandoff("target_without_covered_dimension", target.key);
+    for (const item of handoff.evidence)
+        if (!coverageEvidence.has(item.key))
+            invalidDesignResourceHandoff("evidence_unreferenced", item.key);
+}
+function validateCoveredRow(row, targets, conditions, evidence) {
+    for (const [name, values] of [
+        ["target_refs", row.target_refs],
+        ["condition_refs", row.condition_refs],
+        ["evidence_refs", row.evidence_refs],
+        ["verification_methods", row.verification_methods],
+    ])
+        requireNonemptyDesignResourceValues(values, `coverage_${name}_required:${row.key}`);
+    for (const ref of row.target_refs)
+        requireKnownDesignResourceRef(targets, ref, "target");
+    for (const ref of row.condition_refs)
+        requireKnownDesignResourceRef(conditions, ref, "condition");
+    for (const ref of row.evidence_refs)
+        requireKnownDesignResourceRef(evidence, ref, "evidence");
+    const allowedEvidence = new Set(DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION[row.dimension]);
+    const allowedMethods = new Set(DESIGN_RESOURCE_METHODS_BY_DIMENSION[row.dimension]);
+    for (const ref of row.evidence_refs) {
+        const item = evidence.get(ref);
+        if (!allowedEvidence.has(item.kind))
+            invalidDesignResourceHandoff("coverage_evidence_kind_incompatible", `${row.key}:${row.dimension}:${item.key}:${item.kind}`);
+    }
+    for (const method of row.verification_methods)
+        if (!allowedMethods.has(method))
+            invalidDesignResourceHandoff("coverage_verification_method_incompatible", `${row.key}:${row.dimension}:${method}`);
+    for (const targetRef of row.target_refs)
+        for (const conditionRef of row.condition_refs)
+            if (!row.evidence_refs.some((evidenceRef) => {
+                const item = evidence.get(evidenceRef);
+                return (targets.get(targetRef).resource_refs.includes(item.resource_ref) &&
+                    item.condition_refs.includes(conditionRef));
+            }))
+                invalidDesignResourceHandoff("coverage_cell_without_evidence", `${row.key}:${targetRef}:${conditionRef}`);
+}
+function validateNoncoveredRow(row) {
+    for (const [name, values] of [
+        ["evidence_refs", row.evidence_refs],
+        ["verification_methods", row.verification_methods],
+    ])
+        if (values.length)
+            invalidDesignResourceHandoff("noncovered_binding_forbidden", `${row.key}:${row.disposition}:${name}`);
+}

package/dist/lib/design-resource-handoff-validation-primitives.d.ts

@@ -0,0 +1,11 @@
+export declare function indexDesignResourceItems<T extends {
+    key: string;
+}>(items: T[]): Map<string, T>;
+export declare function requireUniqueDesignResourceObjects(items: Array<{
+    key: string;
+}>, code: string): void;
+export declare function requireUniqueDesignResourceValues<T>(values: T[], code: string): void;
+export declare function requireNonemptyDesignResourceValues(values: readonly unknown[], code: string): void;
+export declare function requireKnownDesignResourceRef(known: Map<string, unknown> | Set<string>, ref: string, kind: string): void;
+export declare function requireDesignSourceItemKind(sourceItems: Map<string, string>, ref: string): void;
+export declare function invalidDesignResourceHandoff(code: string, detail: string): never;

package/dist/lib/design-resource-handoff-validation-primitives.js

@@ -0,0 +1,26 @@
+export function indexDesignResourceItems(items) {
+    return new Map(items.map((item) => [item.key, item]));
+}
+export function requireUniqueDesignResourceObjects(items, code) {
+    requireUniqueDesignResourceValues(items.map((item) => item.key), code);
+}
+export function requireUniqueDesignResourceValues(values, code) {
+    if (new Set(values).size !== values.length)
+        invalidDesignResourceHandoff(code, "duplicate");
+}
+export function requireNonemptyDesignResourceValues(values, code) {
+    if (!values.length)
+        invalidDesignResourceHandoff(code, "empty");
+}
+export function requireKnownDesignResourceRef(known, ref, kind) {
+    if (!known.has(ref))
+        invalidDesignResourceHandoff(`${kind}_ref_unknown`, ref);
+}
+export function requireDesignSourceItemKind(sourceItems, ref) {
+    const kind = sourceItems.get(ref);
+    if (!["requirement", "control", "acceptance"].includes(kind))
+        invalidDesignResourceHandoff("design_source_item_kind_unsupported", `${ref}:${kind}`);
+}
+export function invalidDesignResourceHandoff(code, detail) {
+    throw new Error(`design_resource_handoff_invalid:${code}:${detail}`);
+}

package/dist/lib/design-resource-handoff-validation-structure.d.ts

@@ -0,0 +1,6 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceScope(handoff: DesignResourceHandoffV1): void;
+export declare function validateDesignResourceConditions(handoff: DesignResourceHandoffV1): void;
+export declare function validateDesignResourceSubjects(handoff: DesignResourceHandoffV1, targets: Map<string, DesignResourceHandoffV1["targets"][number]>): void;
+export declare function validateDesignResourceTargets(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, conditions: Map<string, DesignResourceHandoffV1["conditions"][number]>): void;
+export declare function validateDesignResourceEvidence(handoff: DesignResourceHandoffV1, resources: Map<string, unknown>, conditions: Map<string, unknown>): void;