project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -1,10 +1,10 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { htmlAttributes, isTextResource, } from "./design-resource-handoff-file-primitives.js";
+import { isTextResource, } from "./design-resource-handoff-file-primitives.js";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-import { validateDesignResourceWebDependencyClosure } from "./design-resource-handoff-web-dependency-validation.js";
+import { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-validation.js";
+import { validateDesignResourceImplementationDependencyClosure } from "./design-resource-handoff-web-dependency-validation.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { markdownAnchors } from "./long-task-source-validation.js";
 export async function validateDesignResourceFiles(repository, parsed) {
     const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
     const contents = new Map();
@@ -15,8 +15,9 @@ export async function validateDesignResourceFiles(repository, parsed) {
     for (const evidence of parsed.handoff.evidence)
         validateLocator(evidence, resources.get(evidence.resource_ref), contents.get(evidence.resource_ref));
     for (const target of parsed.handoff.targets)
-        if (target.source_profile.kind === "implementation_web")
-            validateDesignResourceWebDependencyClosure(target, resources, contents);
+        if (target.source_profile.kind === "implementation_web" ||
+            target.source_profile.kind === "implementation_app")
+            validateDesignResourceImplementationDependencyClosure(target, resources, contents);
 }
 function validateLocator(evidence, resource, bytes) {
     const { kind, value } = evidence.locator;
@@ -30,37 +31,7 @@ function validateLocator(evidence, resource, bytes) {
             invalidDesignResourceHandoff("locator_whole_resource_too_broad", label);
         return;
     }
-    const content = bytes.toString("utf8");
-    if (kind === "html_selector") {
-        requireMediaType(resource, ["text/html", "application/xhtml+xml"], label);
-        if (!htmlSelectorExists(content, value))
-            invalidDesignResourceHandoff("locator_not_found", label);
-        return;
-    }
-    if (kind === "markdown_anchor") {
-        requireMediaType(resource, ["text/markdown"], label);
-        if (value.startsWith("#") || !markdownAnchors(content).has(value))
-            invalidDesignResourceHandoff("locator_not_found", label);
-        return;
-    }
-    if (kind === "json_pointer") {
-        requireMediaType(resource, ["application/json"], label);
-        if (!jsonPointerExists(content, value))
-            invalidDesignResourceHandoff("locator_not_found", label);
-        return;
-    }
-    if (kind === "css_selector") {
-        requireMediaType(resource, ["text/css"], label);
-        if (!cssSelectorExists(content, value))
-            invalidDesignResourceHandoff("locator_not_found", label);
-        return;
-    }
-    requireMediaType(resource, ["text/css"], label);
-    if (!/^--[A-Za-z0-9_-]+$/u.test(value))
-        invalidDesignResourceHandoff("locator_css_custom_property_invalid", label);
-    const customProperty = new RegExp(`${escapeRegExp(value)}\\s*:`, "u");
-    if (!customProperty.test(content))
-        invalidDesignResourceHandoff("locator_not_found", label);
+    resolveDesignResourceLocatorValue({ resource_ref: resource.key, kind, value }, resource, bytes, `evidence.${evidence.key}`);
 }
 function validateEvidenceResourceCompatibility(evidence, resource) {
     const machineReadableKinds = new Set([
@@ -72,71 +43,13 @@ function validateEvidenceResourceCompatibility(evidence, resource) {
         "semantic_tree",
         "token_spec",
         "annotation",
+        "localization_spec",
+        "system_ui_spec",
+        "haptic_spec",
+        "sound_spec",
+        "render_environment",
+        "relation_spec",
     ]);
     if (machineReadableKinds.has(evidence.kind) && !isTextResource(resource))
         invalidDesignResourceHandoff("evidence_resource_media_type_incompatible", `${evidence.key}:${evidence.kind}:${resource.media_type}`);
 }
-function requireMediaType(resource, expected, detail) {
-    if (!expected.includes(resource.media_type))
-        invalidDesignResourceHandoff("locator_media_type_incompatible", `${detail}:${resource.media_type}`);
-}
-function htmlSelectorExists(content, selector) {
-    const parsed = /^(?:([A-Za-z][A-Za-z0-9:-]*))?(?:#([A-Za-z][A-Za-z0-9_.:-]*))?(?:\[([A-Za-z_:][A-Za-z0-9_.:-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\]\s]+)))?\])?$/u.exec(selector);
-    if (!parsed || (!parsed[1] && !parsed[2] && !parsed[3]))
-        invalidDesignResourceHandoff("locator_html_selector_unsupported", selector);
-    const [, expectedTag, expectedId, expectedAttribute] = parsed;
-    const expectedValue = parsed[4] ?? parsed[5] ?? parsed[6];
-    for (const match of content.matchAll(/<([A-Za-z][A-Za-z0-9:-]*)\b([^<>]*)>/gu)) {
-        if (expectedTag && match[1].toLowerCase() !== expectedTag.toLowerCase())
-            continue;
-        const attributes = htmlAttributes(match[2]);
-        if (expectedId && attributes.get("id") !== expectedId)
-            continue;
-        if (expectedAttribute) {
-            const attributeName = expectedAttribute.toLowerCase();
-            if (!attributes.has(attributeName))
-                continue;
-            if (expectedValue !== undefined &&
-                attributes.get(attributeName) !== expectedValue)
-                continue;
-        }
-        return true;
-    }
-    return false;
-}
-function jsonPointerExists(content, pointer) {
-    if (!pointer.startsWith("/"))
-        return false;
-    let current;
-    try {
-        current = JSON.parse(content);
-    }
-    catch {
-        return false;
-    }
-    for (const token of pointer
-        .slice(1)
-        .split("/")
-        .map((part) => part.replace(/~1/gu, "/").replace(/~0/gu, "~"))) {
-        if (current === null ||
-            typeof current !== "object" ||
-            !Object.hasOwn(current, token))
-            return false;
-        current = current[token];
-    }
-    return true;
-}
-function cssSelectorExists(content, selector) {
-    if (!selector.trim() || selector.includes("{") || selector.includes("}"))
-        invalidDesignResourceHandoff("locator_css_selector_unsupported", selector);
-    for (const match of content.matchAll(/(?:^|\})\s*([^@{}][^{}]*)\{/gmu))
-        if (match[1]
-            .split(",")
-            .map((item) => item.trim())
-            .includes(selector))
-            return true;
-    return false;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}

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

@@ -1,3 +1,4 @@
 import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 export declare const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceEvidenceKind[]>;
 export declare const DESIGN_RESOURCE_METHODS_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceVerificationMethod[]>;
+export declare const DESIGN_RESOURCE_EVIDENCE_BY_METHOD: Record<DesignResourceVerificationMethod, readonly DesignResourceEvidenceKind[]>;

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

@@ -3,14 +3,23 @@ export const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION = {
         "frame",
         "prototype_state",
         "prototype_transition",
+        "relation_spec",
+        "annotation",
+    ],
+    visual_content: [
+        "frame",
+        "component_variant",
+        "token_spec",
+        "localization_spec",
+        "render_environment",
         "annotation",
     ],
-    visual_content: ["frame", "component_variant", "token_spec", "annotation"],
     component_control: [
         "frame",
         "component_variant",
         "prototype_state",
         "token_spec",
+        "relation_spec",
         "annotation",
     ],
     state_interaction: [
@@ -18,19 +27,117 @@ export const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION = {
         "prototype_state",
         "prototype_transition",
         "input_spec",
+        "haptic_spec",
+        "sound_spec",
+        "sound_capture",
+        "system_ui_spec",
+    ],
+    motion: [
+        "prototype_transition",
+        "motion_spec",
+        "motion_capture",
+        "haptic_spec",
+        "sound_spec",
+        "sound_capture",
+    ],
+    adaptation_input: [
+        "responsive_spec",
+        "input_spec",
+        "localization_spec",
+        "system_ui_spec",
+        "render_environment",
     ],
-    motion: ["prototype_transition", "motion_spec", "motion_capture"],
-    adaptation_input: ["responsive_spec", "input_spec"],
-    accessibility: ["accessibility_spec", "semantic_tree", "input_spec"],
+    accessibility: ["accessibility_spec", "semantic_tree", "input_spec", "frame"],
     assets: ["asset", "token_spec", "annotation"],
 };
 export const DESIGN_RESOURCE_METHODS_BY_DIMENSION = {
-    surface_flow: ["layout_geometry", "interaction_trace"],
-    visual_content: ["visual_pixel", "design_token", "content"],
-    component_control: ["visual_pixel", "design_token", "component_state"],
-    state_interaction: ["component_state", "interaction_trace"],
-    motion: ["motion_timeline"],
-    adaptation_input: ["responsive_reflow", "input_method"],
-    accessibility: ["accessibility_semantics"],
+    surface_flow: [
+        "layout_geometry",
+        "design_token",
+        "interaction_trace",
+        "scroll_navigation",
+    ],
+    visual_content: [
+        "layout_geometry",
+        "visual_pixel",
+        "design_token",
+        "content",
+        "responsive_reflow",
+        "localization",
+    ],
+    component_control: [
+        "layout_geometry",
+        "visual_pixel",
+        "design_token",
+        "component_state",
+    ],
+    state_interaction: [
+        "component_state",
+        "interaction_trace",
+        "gesture_trace",
+        "scroll_navigation",
+        "input_method",
+        "system_ui",
+        "haptic_feedback",
+        "sound_feedback",
+    ],
+    motion: ["motion_timeline", "haptic_feedback", "sound_feedback"],
+    adaptation_input: [
+        "layout_geometry",
+        "responsive_reflow",
+        "input_method",
+        "scroll_navigation",
+        "localization",
+        "system_ui",
+    ],
+    accessibility: [
+        "accessibility_semantics",
+        "accessibility_navigation",
+        "accessibility_visual",
+    ],
     assets: ["asset_integrity"],
 };
+export const DESIGN_RESOURCE_EVIDENCE_BY_METHOD = {
+    layout_geometry: [
+        "frame",
+        "component_variant",
+        "responsive_spec",
+        "relation_spec",
+        "annotation",
+    ],
+    visual_pixel: ["frame", "component_variant", "render_environment"],
+    design_token: ["token_spec", "component_variant", "annotation"],
+    content: ["frame", "component_variant", "localization_spec", "annotation"],
+    component_state: [
+        "component_variant",
+        "prototype_state",
+        "prototype_transition",
+    ],
+    interaction_trace: [
+        "prototype_transition",
+        "input_spec",
+        "system_ui_spec",
+        "haptic_spec",
+    ],
+    motion_timeline: ["prototype_transition", "motion_spec", "motion_capture"],
+    responsive_reflow: [
+        "responsive_spec",
+        "component_variant",
+        "render_environment",
+    ],
+    input_method: ["input_spec", "prototype_transition"],
+    accessibility_semantics: ["accessibility_spec", "semantic_tree"],
+    accessibility_navigation: [
+        "accessibility_spec",
+        "semantic_tree",
+        "input_spec",
+    ],
+    accessibility_visual: ["accessibility_spec", "frame"],
+    gesture_trace: ["input_spec", "prototype_transition", "motion_capture"],
+    scroll_navigation: ["prototype_transition", "responsive_spec", "input_spec"],
+    localization: ["localization_spec", "component_variant", "frame"],
+    system_ui: ["system_ui_spec", "prototype_transition"],
+    haptic_feedback: ["haptic_spec", "prototype_transition"],
+    sound_feedback: ["sound_spec", "sound_capture", "prototype_transition"],
+    asset_integrity: ["asset"],
+};

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

@@ -1,6 +1,8 @@
+import { DESIGN_RESOURCE_VALUE_KINDS } from "./design-resource-fact-manifest-types.js";
+import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
 import { DESIGN_RESOURCE_DIMENSIONS, DESIGN_RESOURCE_EVIDENCE_KINDS, DESIGN_RESOURCE_LOCATOR_KINDS, } from "./design-resource-handoff-types.js";
 import { contractKey, contractKeys, sourceItemKeys, stableKey, stableKeys, verificationMethods, } from "./design-resource-handoff-shape-primitives.js";
-import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+import { array, literal, nullable, object, string, text, } from "./long-task-shape-primitives.js";
 import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
 export function parseDesignResourceHandoffEvidence(value) {
     return array(value, "design_resource_handoff.evidence").map((item, index) => {
@@ -35,8 +37,12 @@ export function parseDesignResourceHandoffCoverage(value) {
             "disposition",
             "target_refs",
             "condition_refs",
+            "variation_refs",
+            "property_refs",
             "evidence_refs",
+            "fact_cell_refs",
             "fact_refs",
+            "proof_obligation_refs",
             "source_item_refs",
             "verification_methods",
             "rationale",
@@ -54,8 +60,12 @@ export function parseDesignResourceHandoffCoverage(value) {
             ], `${label}.disposition`),
             target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
             condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
+            variation_refs: stableKeys(row.variation_refs, `${label}.variation_refs`),
+            property_refs: stableKeys(row.property_refs, `${label}.property_refs`),
             evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
+            fact_cell_refs: stableKeys(row.fact_cell_refs, `${label}.fact_cell_refs`),
             fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
+            proof_obligation_refs: stableKeys(row.proof_obligation_refs, `${label}.proof_obligation_refs`),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
             verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
             rationale: string(row.rationale, `${label}.rationale`),
@@ -67,25 +77,52 @@ export function parseDesignResourceHandoffFacts(value) {
         const label = `design_resource_handoff.facts[${index}]`;
         const row = object(item, label, [
             "key",
+            "cell_ref",
             "subject_ref",
             "target_ref",
             "condition_ref",
+            "variation_ref",
+            "property_ref",
             "dimension",
             "observation_scope",
+            "observation_sensitivity",
+            "value_kind",
+            "value",
             "evidence_refs",
             "source_item_refs",
-            "verification_method",
+            "lineage",
+        ]);
+        const lineage = object(row.lineage, `${label}.lineage`, [
+            "design_system_ref",
+            "token_chain_refs",
+            "override_chain_refs",
+            "resolved_value",
+            "conflict_status",
+            "conflict_resolution",
         ]);
         return {
             key: stableKey(row.key, `${label}.key`),
+            cell_ref: stableKey(row.cell_ref, `${label}.cell_ref`),
             subject_ref: stableKey(row.subject_ref, `${label}.subject_ref`),
             target_ref: contractKey(row.target_ref, `${label}.target_ref`),
             condition_ref: contractKey(row.condition_ref, `${label}.condition_ref`),
+            variation_ref: stableKey(row.variation_ref, `${label}.variation_ref`),
+            property_ref: stableKey(row.property_ref, `${label}.property_ref`),
             dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimension`),
             observation_scope: literal(row.observation_scope, ["subject", "full_target"], `${label}.observation_scope`),
+            observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
+            value_kind: literal(row.value_kind, DESIGN_RESOURCE_VALUE_KINDS, `${label}.value_kind`),
+            value: parseDesignResourceLocatedDigest(row.value, `${label}.value`),
             evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
-            verification_method: verificationMethods([row.verification_method], `${label}.verification_method`)[0],
+            lineage: {
+                design_system_ref: nullable(lineage.design_system_ref, (item) => stableKey(item, `${label}.lineage.design_system_ref`)),
+                token_chain_refs: stableKeys(lineage.token_chain_refs, `${label}.lineage.token_chain_refs`),
+                override_chain_refs: stableKeys(lineage.override_chain_refs, `${label}.lineage.override_chain_refs`),
+                resolved_value: parseDesignResourceLocatedDigest(lineage.resolved_value, `${label}.lineage.resolved_value`),
+                conflict_status: literal(lineage.conflict_status, ["none", "resolved"], `${label}.lineage.conflict_status`),
+                conflict_resolution: text(lineage.conflict_resolution, `${label}.lineage.conflict_resolution`),
+            },
         };
     });
 }
@@ -125,6 +162,9 @@ export function parseDesignResourceHandoffBlockers(value) {
             "target_refs",
             "subject_refs",
             "dimensions",
+            "fact_cell_refs",
+            "fact_refs",
+            "proof_obligation_refs",
             "source_item_refs",
             "verification_methods",
             "required_capabilities",
@@ -135,6 +175,9 @@ export function parseDesignResourceHandoffBlockers(value) {
             target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
             subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
             dimensions: array(row.dimensions, `${label}.dimensions`).map((dimension, itemIndex) => literal(dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimensions[${itemIndex}]`)),
+            fact_cell_refs: stableKeys(row.fact_cell_refs, `${label}.fact_cell_refs`),
+            fact_refs: stableKeys(row.fact_refs, `${label}.fact_refs`),
+            proof_obligation_refs: stableKeys(row.proof_obligation_refs, `${label}.proof_obligation_refs`),
             source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
             verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
             required_capabilities: array(row.required_capabilities, `${label}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${label}.required_capabilities[${capabilityIndex}]`)),

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

@@ -6,4 +6,9 @@ export declare function contractKeys(value: unknown, label: string): string[];
 export declare function sourceItemKeys(value: unknown, label: string): string[];
 export declare function verificationMethods(value: unknown, label: string): DesignResourceHandoffCoverageV1["verification_methods"];
 export declare function positiveInteger(value: unknown, label: string): number;
+export declare function nonnegativeInteger(value: unknown, label: string): number;
+export declare function positiveNumber(value: unknown, label: string): number;
+export declare function nonnegativeNumber(value: unknown, label: string): number;
+export declare function sha256(value: unknown, label: string): string;
+export declare function atomicAxisValue(value: unknown, label: string): string;
 export declare function designResourceShapeFail(label: string, message: string): never;

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

@@ -2,6 +2,7 @@ import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-
 import { array, literal, string } from "./long-task-shape-primitives.js";
 const KEY = /^[a-z0-9][a-z0-9._-]*$/u;
 const SOURCE_ITEM_KEY = /^[a-z0-9][a-z0-9-]*$/u;
+const SHA256 = /^[a-f0-9]{64}$/u;
 export function stableKey(value, label) {
     const result = string(value, label);
     if (!KEY.test(result))
@@ -37,6 +38,33 @@ export function positiveInteger(value, label) {
         designResourceShapeFail(label, "must be a positive safe integer");
     return value;
 }
+export function nonnegativeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        designResourceShapeFail(label, "must be a non-negative safe integer");
+    return Number(value);
+}
+export function positiveNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        designResourceShapeFail(label, "must be a positive finite number");
+    return value;
+}
+export function nonnegativeNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        designResourceShapeFail(label, "must be a non-negative finite number");
+    return value;
+}
+export function sha256(value, label) {
+    const result = string(value, label);
+    if (!SHA256.test(result))
+        designResourceShapeFail(label, "must be a lowercase SHA-256");
+    return result;
+}
+export function atomicAxisValue(value, label) {
+    const result = stableKey(value, label);
+    if (/^all-/u.test(result) || /(?:^|[._-])catalog(?:$|[._-])/u.test(result))
+        designResourceShapeFail(label, "must identify one atomic value, not a compound collection");
+    return result;
+}
 export function designResourceShapeFail(label, message) {
     throw new Error(`design_resource_handoff_invalid:${label}:${message}`);
 }