project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -1,5 +1,6 @@
-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";
+import { DESIGN_RESOURCE_SUBJECT_KINDS, DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS, } from "./design-resource-fact-manifest-types.js";
+import { atomicAxisValue, contractKey, contractKeys, designResourceShapeFail, nonnegativeNumber, positiveInteger, positiveNumber, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, nullable, object, repositoryFile, string, } 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) => {
@@ -36,31 +37,123 @@ export function parseDesignResourceHandoffConditions(value) {
         const row = object(item, label, [
             "key",
             "platform",
+            "os_version",
+            "device_profile",
+            "form_factor",
             "viewport",
-            "modes",
-            "states",
-            "content_cases",
-            "input_methods",
+            "orientation",
+            "density",
+            "safe_area",
+            "window_state",
+            "fold_state",
+            "display_mode",
+            "color_scheme",
+            "locale",
+            "language",
+            "script",
+            "direction",
+            "pseudo_localization",
+            "content_case",
+            "data_case",
+            "text_scale",
+            "input_method",
+            "assistive_technology",
             "motion",
+            "transparency",
+            "contrast",
+            "bold_text",
+            "button_shapes",
+            "system_ui",
+            "ime",
+            "permission",
+            "capability",
+            "connectivity",
+            "lifecycle",
+            "custom_axes",
         ]);
         const viewport = object(row.viewport, `${label}.viewport`, [
+            "key",
             "width",
             "height",
             "unit",
         ]);
+        const density = object(row.density, `${label}.density`, [
+            "key",
+            "pixel_ratio",
+        ]);
+        const safeArea = object(row.safe_area, `${label}.safe_area`, [
+            "key",
+            "top",
+            "right",
+            "bottom",
+            "left",
+            "unit",
+        ]);
+        const textScale = object(row.text_scale, `${label}.text_scale`, [
+            "key",
+            "multiplier",
+        ]);
         return {
             key: contractKey(row.key, `${label}.key`),
-            platform: string(row.platform, `${label}.platform`),
+            platform: atomicAxisValue(row.platform, `${label}.platform`),
+            os_version: atomicAxisValue(row.os_version, `${label}.os_version`),
+            device_profile: atomicAxisValue(row.device_profile, `${label}.device_profile`),
+            form_factor: atomicAxisValue(row.form_factor, `${label}.form_factor`),
             viewport: {
+                key: atomicAxisValue(viewport.key, `${label}.viewport.key`),
                 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`),
+            orientation: atomicAxisValue(row.orientation, `${label}.orientation`),
+            density: {
+                key: atomicAxisValue(density.key, `${label}.density.key`),
+                pixel_ratio: positiveNumber(density.pixel_ratio, `${label}.density.pixel_ratio`),
+            },
+            safe_area: {
+                key: atomicAxisValue(safeArea.key, `${label}.safe_area.key`),
+                top: nonnegativeNumber(safeArea.top, `${label}.safe_area.top`),
+                right: nonnegativeNumber(safeArea.right, `${label}.safe_area.right`),
+                bottom: nonnegativeNumber(safeArea.bottom, `${label}.safe_area.bottom`),
+                left: nonnegativeNumber(safeArea.left, `${label}.safe_area.left`),
+                unit: literal(safeArea.unit, ["px"], `${label}.safe_area.unit`),
+            },
+            window_state: atomicAxisValue(row.window_state, `${label}.window_state`),
+            fold_state: atomicAxisValue(row.fold_state, `${label}.fold_state`),
+            display_mode: atomicAxisValue(row.display_mode, `${label}.display_mode`),
+            color_scheme: atomicAxisValue(row.color_scheme, `${label}.color_scheme`),
+            locale: atomicAxisValue(row.locale, `${label}.locale`),
+            language: atomicAxisValue(row.language, `${label}.language`),
+            script: atomicAxisValue(row.script, `${label}.script`),
+            direction: literal(row.direction, ["ltr", "rtl", "not_applicable"], `${label}.direction`),
+            pseudo_localization: atomicAxisValue(row.pseudo_localization, `${label}.pseudo_localization`),
+            content_case: atomicAxisValue(row.content_case, `${label}.content_case`),
+            data_case: atomicAxisValue(row.data_case, `${label}.data_case`),
+            text_scale: {
+                key: atomicAxisValue(textScale.key, `${label}.text_scale.key`),
+                multiplier: positiveNumber(textScale.multiplier, `${label}.text_scale.multiplier`),
+            },
+            input_method: atomicAxisValue(row.input_method, `${label}.input_method`),
+            assistive_technology: atomicAxisValue(row.assistive_technology, `${label}.assistive_technology`),
+            motion: atomicAxisValue(row.motion, `${label}.motion`),
+            transparency: atomicAxisValue(row.transparency, `${label}.transparency`),
+            contrast: atomicAxisValue(row.contrast, `${label}.contrast`),
+            bold_text: atomicAxisValue(row.bold_text, `${label}.bold_text`),
+            button_shapes: atomicAxisValue(row.button_shapes, `${label}.button_shapes`),
+            system_ui: atomicAxisValue(row.system_ui, `${label}.system_ui`),
+            ime: atomicAxisValue(row.ime, `${label}.ime`),
+            permission: atomicAxisValue(row.permission, `${label}.permission`),
+            capability: atomicAxisValue(row.capability, `${label}.capability`),
+            connectivity: atomicAxisValue(row.connectivity, `${label}.connectivity`),
+            lifecycle: atomicAxisValue(row.lifecycle, `${label}.lifecycle`),
+            custom_axes: array(row.custom_axes, `${label}.custom_axes`).map((item, itemIndex) => {
+                const itemLabel = `${label}.custom_axes[${itemIndex}]`;
+                const custom = object(item, itemLabel, ["axis_ref", "value_ref"]);
+                return {
+                    axis_ref: stableKey(custom.axis_ref, `${itemLabel}.axis_ref`),
+                    value_ref: atomicAxisValue(custom.value_ref, `${itemLabel}.value_ref`),
+                };
+            }),
         };
     });
 }
@@ -72,20 +165,41 @@ export function parseDesignResourceHandoffSubjects(value) {
             "kind",
             "stable_keys",
             "target_refs",
+            "parent_ref",
+            "instance_of_ref",
+            "slot_key",
+            "override_of_ref",
+            "family_ref",
+            "presence",
+            "presence_rule_ref",
+            "population_ref",
+            "portal_host_ref",
+            "relation_endpoints",
+            "census_refs",
         ]);
         return {
             key: stableKey(row.key, `${label}.key`),
-            kind: literal(row.kind, [
-                "surface",
-                "flow",
-                "region",
-                "component_family",
-                "control",
-                "state",
-                "asset",
-            ], `${label}.kind`),
+            kind: literal(row.kind, DESIGN_RESOURCE_SUBJECT_KINDS, `${label}.kind`),
             stable_keys: stableKeys(row.stable_keys, `${label}.stable_keys`),
             target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
+            parent_ref: nullable(row.parent_ref, (item) => stableKey(item, `${label}.parent_ref`)),
+            instance_of_ref: nullable(row.instance_of_ref, (item) => stableKey(item, `${label}.instance_of_ref`)),
+            slot_key: nullable(row.slot_key, (item) => stableKey(item, `${label}.slot_key`)),
+            override_of_ref: nullable(row.override_of_ref, (item) => stableKey(item, `${label}.override_of_ref`)),
+            family_ref: nullable(row.family_ref, (item) => stableKey(item, `${label}.family_ref`)),
+            presence: literal(row.presence, DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS, `${label}.presence`),
+            presence_rule_ref: nullable(row.presence_rule_ref, (item) => stableKey(item, `${label}.presence_rule_ref`)),
+            population_ref: nullable(row.population_ref, (item) => stableKey(item, `${label}.population_ref`)),
+            portal_host_ref: nullable(row.portal_host_ref, (item) => stableKey(item, `${label}.portal_host_ref`)),
+            relation_endpoints: array(row.relation_endpoints, `${label}.relation_endpoints`).map((endpoint, endpointIndex) => {
+                const endpointLabel = `${label}.relation_endpoints[${endpointIndex}]`;
+                const parsed = object(endpoint, endpointLabel, ["role", "subject_ref"]);
+                return {
+                    role: stableKey(parsed.role, `${endpointLabel}.role`),
+                    subject_ref: stableKey(parsed.subject_ref, `${endpointLabel}.subject_ref`),
+                };
+            }),
+            census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
         };
     });
 }
@@ -100,7 +214,13 @@ export function parseDesignResourceHandoffTargets(value) {
             "source_profile",
             "selection_basis",
         ]);
-        const sourceProfile = object(row.source_profile, `${label}.source_profile`, ["kind", "entry_resource_ref", "dependency_resource_refs", "acquisition"]);
+        const sourceProfile = object(row.source_profile, `${label}.source_profile`, [
+            "kind",
+            "entry_resource_ref",
+            "dependency_resource_refs",
+            "fact_manifest_resource_ref",
+            "acquisition",
+        ]);
         return {
             key: contractKey(row.key, `${label}.key`),
             interpretation: literal(row.interpretation, ["exact_target", "constraint"], `${label}.interpretation`),
@@ -110,6 +230,7 @@ export function parseDesignResourceHandoffTargets(value) {
                 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`),
+                fact_manifest_resource_ref: stableKey(sourceProfile.fact_manifest_resource_ref, `${label}.source_profile.fact_manifest_resource_ref`),
                 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.js

@@ -1,3 +1,4 @@
+import { parseDesignResourceAssetBindings, parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceEnvironments, parseDesignResourceFactCells, parseDesignResourceLineageNodes, parseDesignResourceOracles, parseDesignResourceProofObligations, parseDesignResourceProperties, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape.js";
 import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } 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";
@@ -9,11 +10,23 @@ export function parseDesignResourceHandoffShape(value) {
         "scope",
         "provenance",
         "resources",
+        "axis_dispositions",
+        "condition_exclusions",
         "conditions",
         "subjects",
+        "variation_axis_dispositions",
+        "variation_exclusions",
+        "variations",
+        "properties",
+        "lineage_nodes",
         "targets",
         "evidence",
+        "fact_cells",
         "facts",
+        "proof_obligations",
+        "oracles",
+        "environments",
+        "asset_bindings",
         "resource_fact_closure",
         "coverage",
         "acceptance_blockers",
@@ -62,11 +75,23 @@ export function parseDesignResourceHandoffShape(value) {
             design_system_id: string(provenance.design_system_id, "design_resource_handoff.provenance.design_system_id"),
         },
         resources: parseDesignResourceHandoffResources(root.resources),
+        axis_dispositions: parseDesignResourceAxisDispositions(root.axis_dispositions),
+        condition_exclusions: parseDesignResourceConditionExclusions(root.condition_exclusions),
         conditions: parseDesignResourceHandoffConditions(root.conditions),
         subjects: parseDesignResourceHandoffSubjects(root.subjects),
+        variation_axis_dispositions: parseDesignResourceVariationAxisDispositions(root.variation_axis_dispositions),
+        variation_exclusions: parseDesignResourceVariationExclusions(root.variation_exclusions),
+        variations: parseDesignResourceVariations(root.variations),
+        properties: parseDesignResourceProperties(root.properties),
+        lineage_nodes: parseDesignResourceLineageNodes(root.lineage_nodes),
         targets: parseDesignResourceHandoffTargets(root.targets),
         evidence: parseDesignResourceHandoffEvidence(root.evidence),
+        fact_cells: parseDesignResourceFactCells(root.fact_cells),
         facts: parseDesignResourceHandoffFacts(root.facts),
+        proof_obligations: parseDesignResourceProofObligations(root.proof_obligations),
+        oracles: parseDesignResourceOracles(root.oracles),
+        environments: parseDesignResourceEnvironments(root.environments),
+        asset_bindings: parseDesignResourceAssetBindings(root.asset_bindings),
         resource_fact_closure: parseDesignResourceHandoffResourceFactClosure(root.resource_fact_closure),
         coverage: parseDesignResourceHandoffCoverage(root.coverage),
         acceptance_blockers: parseDesignResourceHandoffBlockers(root.acceptance_blockers),

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

@@ -1,11 +1,12 @@
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
+import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
 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 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", "localization_spec", "system_ui_spec", "haptic_spec", "sound_spec", "sound_capture", "render_environment", "relation_spec"];
 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 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", "accessibility_navigation", "accessibility_visual", "gesture_trace", "scroll_navigation", "localization", "system_ui", "haptic_feedback", "sound_feedback", "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 declare const DESIGN_RESOURCE_LOCATOR_KINDS: readonly ["html_selector", "html_inner_html", "markdown_anchor", "json_pointer", "css_selector", "css_custom_property", "html_attribute", "css_declaration", "javascript_export", "svg_selector", "svg_inner_xml", "svg_attribute", "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";
@@ -30,11 +31,23 @@ export interface DesignResourceHandoffV1 {
         design_system_id: string;
     };
     resources: DesignResourceHandoffResourceV1[];
+    axis_dispositions: DesignResourceAxisDispositionV1[];
+    condition_exclusions: DesignResourceConditionCombinationDispositionV1[];
     conditions: DesignResourceHandoffConditionV1[];
     subjects: DesignResourceHandoffSubjectV1[];
+    variation_axis_dispositions: DesignResourceVariationAxisDispositionV1[];
+    variation_exclusions: DesignResourceVariationCombinationDispositionV1[];
+    variations: DesignResourceSubjectVariationV1[];
+    properties: DesignResourcePropertyDefinitionV1[];
+    lineage_nodes: DesignResourceLineageNodeV1[];
     targets: DesignResourceHandoffTargetV1[];
     evidence: DesignResourceHandoffEvidenceV1[];
-    facts: DesignResourceHandoffFactV1[];
+    fact_cells: DesignResourceFactCellV1[];
+    facts: DesignResourceFactV1[];
+    proof_obligations: DesignResourceProofObligationV1[];
+    oracles: DesignResourceOracleV1[];
+    environments: DesignResourceEnvironmentV1[];
+    asset_bindings: DesignResourceAssetBindingV1[];
     resource_fact_closure: DesignResourceHandoffResourceFactClosureV1[];
     coverage: DesignResourceHandoffCoverageV1[];
     acceptance_blockers: DesignResourceHandoffBlockerV1[];
@@ -59,22 +72,77 @@ export interface DesignResourceHandoffResourceV1 {
 export interface DesignResourceHandoffConditionV1 {
     key: string;
     platform: string;
+    os_version: string;
+    device_profile: string;
+    form_factor: string;
     viewport: {
+        key: string;
         width: number;
         height: number;
         unit: "px";
     };
-    modes: string[];
-    states: string[];
-    content_cases: string[];
-    input_methods: string[];
-    motion: "full" | "reduced" | "not_applicable";
+    orientation: string;
+    density: {
+        key: string;
+        pixel_ratio: number;
+    };
+    safe_area: {
+        key: string;
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+        unit: "px";
+    };
+    window_state: string;
+    fold_state: string;
+    display_mode: string;
+    color_scheme: string;
+    locale: string;
+    language: string;
+    script: string;
+    direction: "ltr" | "rtl" | "not_applicable";
+    pseudo_localization: string;
+    content_case: string;
+    data_case: string;
+    text_scale: {
+        key: string;
+        multiplier: number;
+    };
+    input_method: string;
+    assistive_technology: string;
+    motion: string;
+    transparency: string;
+    contrast: string;
+    bold_text: string;
+    button_shapes: string;
+    system_ui: string;
+    ime: string;
+    permission: string;
+    capability: string;
+    connectivity: string;
+    lifecycle: string;
+    custom_axes: Array<{
+        axis_ref: string;
+        value_ref: string;
+    }>;
 }
 export interface DesignResourceHandoffSubjectV1 {
     key: string;
-    kind: "surface" | "flow" | "region" | "component_family" | "control" | "state" | "asset";
+    kind: DesignResourceSubjectKind;
     stable_keys: string[];
     target_refs: string[];
+    parent_ref: string | null;
+    instance_of_ref: string | null;
+    slot_key: string | null;
+    override_of_ref: string | null;
+    family_ref: string | null;
+    presence: DesignResourceSubjectPresenceKind;
+    presence_rule_ref: string | null;
+    population_ref: string | null;
+    portal_host_ref: string | null;
+    relation_endpoints: DesignResourceRelationEndpointV1[];
+    census_refs: string[];
 }
 export interface DesignResourceHandoffTargetV1 {
     key: string;
@@ -85,6 +153,7 @@ export interface DesignResourceHandoffTargetV1 {
         kind: DesignResourceSourceProfileKind;
         entry_resource_ref: string;
         dependency_resource_refs: string[];
+        fact_manifest_resource_ref: string;
         acquisition: "complete";
     };
     selection_basis: string;
@@ -99,17 +168,7 @@ export interface DesignResourceHandoffEvidenceV1 {
     };
     condition_refs: string[];
 }
-export interface DesignResourceHandoffFactV1 {
-    key: string;
-    subject_ref: string;
-    target_ref: string;
-    condition_ref: string;
-    dimension: DesignResourceDimension;
-    observation_scope: "subject" | "full_target";
-    evidence_refs: string[];
-    source_item_refs: string[];
-    verification_method: DesignResourceVerificationMethod;
-}
+export type DesignResourceHandoffFactV1 = DesignResourceFactV1;
 export interface DesignResourceHandoffResourceFactClosureV1 {
     key: string;
     resource_ref: string;
@@ -128,8 +187,12 @@ export interface DesignResourceHandoffCoverageV1 {
     disposition: DesignResourceCoverageDisposition;
     target_refs: string[];
     condition_refs: string[];
+    variation_refs: string[];
+    property_refs: string[];
     evidence_refs: string[];
+    fact_cell_refs: string[];
     fact_refs: string[];
+    proof_obligation_refs: string[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
     rationale: string;
@@ -139,6 +202,9 @@ export interface DesignResourceHandoffBlockerV1 {
     target_refs: string[];
     subject_refs: string[];
     dimensions: DesignResourceDimension[];
+    fact_cell_refs: string[];
+    fact_refs: string[];
+    proof_obligation_refs: string[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
     required_capabilities: ExecutionTargetCapabilityV2[];
@@ -156,11 +222,21 @@ export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHa
     resource_hashes: Record<string, string>;
     counts: {
         resources: number;
+        manifests: number;
+        axis_dispositions: number;
         conditions: number;
         subjects: number;
+        variations: number;
+        properties: number;
+        lineage_nodes: number;
         targets: number;
         evidence: number;
+        fact_cells: number;
         facts: number;
+        proof_obligations: number;
+        oracles: number;
+        environments: number;
+        asset_bindings: number;
         resource_fact_closure: number;
         coverage: number;
         acceptance_blockers: number;

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

@@ -22,6 +22,13 @@ export const DESIGN_RESOURCE_EVIDENCE_KINDS = [
     "token_spec",
     "asset",
     "annotation",
+    "localization_spec",
+    "system_ui_spec",
+    "haptic_spec",
+    "sound_spec",
+    "sound_capture",
+    "render_environment",
+    "relation_spec",
 ];
 export const DESIGN_RESOURCE_VERIFICATION_METHODS = [
     "layout_geometry",
@@ -34,13 +41,28 @@ export const DESIGN_RESOURCE_VERIFICATION_METHODS = [
     "responsive_reflow",
     "input_method",
     "accessibility_semantics",
+    "accessibility_navigation",
+    "accessibility_visual",
+    "gesture_trace",
+    "scroll_navigation",
+    "localization",
+    "system_ui",
+    "haptic_feedback",
+    "sound_feedback",
     "asset_integrity",
 ];
 export const DESIGN_RESOURCE_LOCATOR_KINDS = [
     "html_selector",
+    "html_inner_html",
     "markdown_anchor",
     "json_pointer",
     "css_selector",
     "css_custom_property",
+    "html_attribute",
+    "css_declaration",
+    "javascript_export",
+    "svg_selector",
+    "svg_inner_xml",
+    "svg_attribute",
     "whole_resource",
 ];

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

@@ -1,4 +1,4 @@
-import { type DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+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]>, facts: Map<string, DesignResourceHandoffV1["facts"][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;