project-tiny-context-harness 0.8.4 → 0.8.5

package/dist/commands/long-task-authoring.js

@@ -24,6 +24,7 @@ export function compactLongTaskTemplate() {
 }
 function template() {
     return `schema_version: long-task-delivery-v2
+semantic_fact_manifest: {key: replace-semantic-facts, source_path: plans/replace-me.md, sha256: "1111111111111111111111111111111111111111111111111111111111111111"}
 task:
   id: replace-me
   title: Replace me
@@ -76,6 +77,21 @@ outcomes:
         dimensions: [{key: delivery-state, value: ready}]
         given_refs: [source-ready]
         when_refs: [inspect-result]
+    semantic_fact_bindings:
+      manifest_ref: replace-semantic-facts
+      facts:
+        - fact_ref: replace.result.observable
+          claim_ref: semantic_fact.replace.result.observable
+          applicability_ref: root-success
+      proofs:
+        - proof_ref: replace.result.observable.runtime
+          fact_ref: replace.result.observable
+          method: exact_value
+          proof_surface: runtime_behavior
+          evidence_capabilities: [semantic_fact]
+          authority: machine
+          check_ref: replace-check
+          assertion_ref: replace-semantic-fact
     product:
       observable_result: Describe what a user or system can observe.
       result_applicability_refs: [root-success]
@@ -123,6 +139,7 @@ outcomes:
           verification_inputs: ["tests/replace-oracle.mjs"]
           input_paths: [src/replace-me.ts]
           expected_output_paths: [src/replace-me.ts]
+          artifact_globs: [artifacts/replace-semantic-fact.json]
           positive_assertions:
             - key: replace-result
               criterion: The declared outcome is observable.
@@ -132,6 +149,14 @@ outcomes:
               evidence_capabilities: [state_delta, target_runtime]
               operator: equals
               expected: true
+            - key: replace-semantic-fact
+              criterion: The exact Source-indexed semantic Fact passes its frozen comparison on the current target.
+              claims: [semantic_fact.replace.result.observable]
+              applicability_ref: root-success
+              observation: semantic_fact_replace_result_observable
+              evidence_capabilities: [semantic_fact]
+              operator: equals
+              expected: true
             - key: replace-requirement
               criterion: The atomic Source requirement is observable.
               claims: [requirement.replace-requirement]
@@ -167,14 +192,14 @@ outcomes:
       counterfactual_controls:
         - key: replace-semantic-carrier
           binding_key: replace-carrier
-          claims: [result, requirement.replace-requirement, obligation.architecture]
+          claims: [result, requirement.replace-requirement, obligation.architecture, semantic_fact.replace.result.observable]
           check_key: replace-check
           mutation:
             type: replace_text
             path: src/replace-me.ts
             match: IMPLEMENTED_STATE
             replacement: SEMANTIC_FAILURE_STATE
-          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture]
+          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture, replace-semantic-fact]
           preserved_assertions: [replace-liveness]
         - key: replace-relation-applicability
           binding_key: replace-carrier

package/dist/lib/context-templates.js

@@ -46,7 +46,7 @@ export function globalContextTemplate() {
         "",
         "## Next Safe Action",
         "",
-        "- State the safest next step for a fresh agent, including whether the next change should update Context before code.",
+        "- State a stable safe re-entry rule for a fresh agent, including when Context must be updated before code. Do not store task-local progress or a one-off next edit here.",
         "",
         "## Context Index",
         "",

package/dist/lib/design-resource-fact-enums.d.ts

@@ -0,0 +1,20 @@
+export declare const DESIGN_RESOURCE_STANDARD_CONDITION_AXES: readonly ["platform", "os_version", "device_profile", "form_factor", "viewport", "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"];
+export type DesignResourceStandardConditionAxis = (typeof DESIGN_RESOURCE_STANDARD_CONDITION_AXES)[number];
+export declare const DESIGN_RESOURCE_VARIATION_AXES: readonly ["variant", "state", "interaction_phase", "presence_phase", "instance_case"];
+export type DesignResourceVariationAxis = (typeof DESIGN_RESOURCE_VARIATION_AXES)[number];
+export declare const DESIGN_RESOURCE_SUBJECT_KINDS: readonly ["surface", "flow", "region", "overlay", "system_ui", "component_family", "component_instance", "control", "anatomy_part", "slot", "primitive", "text", "icon", "media", "asset", "relation"];
+export type DesignResourceSubjectKind = (typeof DESIGN_RESOURCE_SUBJECT_KINDS)[number];
+export declare const DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS: readonly ["always", "conditional", "lazy", "virtualized", "portal", "overlay", "system_presented"];
+export type DesignResourceSubjectPresenceKind = (typeof DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS)[number];
+export declare const DESIGN_RESOURCE_PROPERTY_FAMILIES: readonly ["geometry", "layout", "scroll", "typography", "color", "decoration", "content", "icon", "media", "interaction", "navigation", "motion", "feedback", "responsive", "accessibility", "asset", "system", "relation"];
+export type DesignResourcePropertyFamily = (typeof DESIGN_RESOURCE_PROPERTY_FAMILIES)[number];
+export declare const DESIGN_RESOURCE_VALUE_KINDS: readonly ["boolean", "color", "digest", "enum", "length", "list", "locator", "number", "ratio", "relation", "semantic", "string", "timeline", "token_ref", "trace"];
+export type DesignResourceValueKind = (typeof DESIGN_RESOURCE_VALUE_KINDS)[number];
+export declare const DESIGN_RESOURCE_LINEAGE_NODE_KINDS: readonly ["base_token", "alias_token", "semantic_token", "component_token", "platform_override", "mode_override", "state_override", "instance_override", "slot_override", "direct_value"];
+export type DesignResourceLineageNodeKind = (typeof DESIGN_RESOURCE_LINEAGE_NODE_KINDS)[number];
+export declare const DESIGN_RESOURCE_COMPARATORS: readonly ["exact_value", "numeric_delta", "geometry_delta", "pixel_diff", "token_resolution", "content_equal", "state_equal", "trace_equal", "timeline_equal", "reflow_equal", "semantic_equal", "asset_equal"];
+export type DesignResourceComparator = (typeof DESIGN_RESOURCE_COMPARATORS)[number];
+export declare const DESIGN_RESOURCE_INSPECTOR_CAPABILITIES: readonly ["html_dom", "css_cascade", "javascript_static", "json", "svg", "markdown", "assets", "design_tokens", "component_anatomy", "prototype_transitions", "responsive_rules", "input_rules", "accessibility", "motion", "localization", "system_ui", "haptics", "audio", "render_capture", "geometry_measurement", "custom_properties", "relations", "dynamic_population"];
+export type DesignResourceInspectorCapability = (typeof DESIGN_RESOURCE_INSPECTOR_CAPABILITIES)[number];
+export declare const DESIGN_RESOURCE_CENSUS_KINDS: readonly ["resource", "node", "declaration", "token", "asset_reference", "relation", "custom_property", "variant", "state", "interaction_phase", "dynamic_population"];
+export type DesignResourceCensusKind = (typeof DESIGN_RESOURCE_CENSUS_KINDS)[number];

package/dist/lib/design-resource-fact-enums.js

@@ -0,0 +1,170 @@
+export const DESIGN_RESOURCE_STANDARD_CONDITION_AXES = [
+    "platform",
+    "os_version",
+    "device_profile",
+    "form_factor",
+    "viewport",
+    "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",
+];
+export const DESIGN_RESOURCE_VARIATION_AXES = [
+    "variant",
+    "state",
+    "interaction_phase",
+    "presence_phase",
+    "instance_case",
+];
+export const DESIGN_RESOURCE_SUBJECT_KINDS = [
+    "surface",
+    "flow",
+    "region",
+    "overlay",
+    "system_ui",
+    "component_family",
+    "component_instance",
+    "control",
+    "anatomy_part",
+    "slot",
+    "primitive",
+    "text",
+    "icon",
+    "media",
+    "asset",
+    "relation",
+];
+export const DESIGN_RESOURCE_SUBJECT_PRESENCE_KINDS = [
+    "always",
+    "conditional",
+    "lazy",
+    "virtualized",
+    "portal",
+    "overlay",
+    "system_presented",
+];
+export const DESIGN_RESOURCE_PROPERTY_FAMILIES = [
+    "geometry",
+    "layout",
+    "scroll",
+    "typography",
+    "color",
+    "decoration",
+    "content",
+    "icon",
+    "media",
+    "interaction",
+    "navigation",
+    "motion",
+    "feedback",
+    "responsive",
+    "accessibility",
+    "asset",
+    "system",
+    "relation",
+];
+export const DESIGN_RESOURCE_VALUE_KINDS = [
+    "boolean",
+    "color",
+    "digest",
+    "enum",
+    "length",
+    "list",
+    "locator",
+    "number",
+    "ratio",
+    "relation",
+    "semantic",
+    "string",
+    "timeline",
+    "token_ref",
+    "trace",
+];
+export const DESIGN_RESOURCE_LINEAGE_NODE_KINDS = [
+    "base_token",
+    "alias_token",
+    "semantic_token",
+    "component_token",
+    "platform_override",
+    "mode_override",
+    "state_override",
+    "instance_override",
+    "slot_override",
+    "direct_value",
+];
+export const DESIGN_RESOURCE_COMPARATORS = [
+    "exact_value",
+    "numeric_delta",
+    "geometry_delta",
+    "pixel_diff",
+    "token_resolution",
+    "content_equal",
+    "state_equal",
+    "trace_equal",
+    "timeline_equal",
+    "reflow_equal",
+    "semantic_equal",
+    "asset_equal",
+];
+export const DESIGN_RESOURCE_INSPECTOR_CAPABILITIES = [
+    "html_dom",
+    "css_cascade",
+    "javascript_static",
+    "json",
+    "svg",
+    "markdown",
+    "assets",
+    "design_tokens",
+    "component_anatomy",
+    "prototype_transitions",
+    "responsive_rules",
+    "input_rules",
+    "accessibility",
+    "motion",
+    "localization",
+    "system_ui",
+    "haptics",
+    "audio",
+    "render_capture",
+    "geometry_measurement",
+    "custom_properties",
+    "relations",
+    "dynamic_population",
+];
+export const DESIGN_RESOURCE_CENSUS_KINDS = [
+    "resource",
+    "node",
+    "declaration",
+    "token",
+    "asset_reference",
+    "relation",
+    "custom_property",
+    "variant",
+    "state",
+    "interaction_phase",
+    "dynamic_population",
+];

package/dist/lib/design-resource-fact-locator-extractors.d.ts

@@ -0,0 +1,8 @@
+export declare function cssRuleBody(content: string, selector: string, detail: string): string;
+export declare function htmlOpeningTag(content: string, selector: string, detail: string): string;
+export declare function htmlAttribute(content: string, selector: string, attribute: string, detail: string): string;
+export declare function elementInnerContent(content: string, selector: string, detail: string): string;
+export declare function markdownSection(content: string, anchor: string, detail: string): string;
+export declare function javascriptExport(content: string, identifier: string, detail: string): string;
+export declare function uniqueCapture(content: string, expression: RegExp, detail: string): string;
+export declare function escapeRegExp(value: string): string;

package/dist/lib/design-resource-fact-locator-extractors.js

@@ -0,0 +1,108 @@
+import { htmlAttributes } from "./design-resource-handoff-file-primitives.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+export function cssRuleBody(content, selector, detail) {
+    const bodies = [];
+    for (const match of content.matchAll(/(?:^|\})\s*([^@{}][^{}]*)\{([^{}]*)\}/gmu)) {
+        if (match[1]
+            .split(",")
+            .map((item) => item.trim())
+            .includes(selector))
+            bodies.push(match[2]);
+    }
+    if (bodies.length !== 1)
+        invalidDesignResourceHandoff(bodies.length ? "locator_ambiguous" : "locator_not_found", detail);
+    return bodies[0];
+}
+export function htmlOpeningTag(content, selector, detail) {
+    const matches = matchingHtmlTags(content, selector, detail);
+    if (matches.length !== 1)
+        invalidDesignResourceHandoff(matches.length ? "locator_ambiguous" : "locator_not_found", detail);
+    return matches[0].tag;
+}
+export function htmlAttribute(content, selector, attribute, detail) {
+    const matches = matchingHtmlTags(content, selector, detail);
+    if (matches.length !== 1)
+        invalidDesignResourceHandoff(matches.length ? "locator_ambiguous" : "locator_not_found", detail);
+    const attributes = htmlAttributes(matches[0].attributes);
+    const value = attributes.get(attribute.toLowerCase());
+    if (value === undefined)
+        invalidDesignResourceHandoff("locator_not_found", detail);
+    return value;
+}
+export function elementInnerContent(content, selector, detail) {
+    const opening = htmlOpeningTag(content, selector, detail);
+    const tagName = /^<([A-Za-z][A-Za-z0-9:-]*)\b/u.exec(opening)?.[1];
+    if (!tagName || /\/\s*>$/u.test(opening))
+        invalidDesignResourceHandoff("locator_element_has_no_content", detail);
+    const start = content.indexOf(opening);
+    const close = new RegExp(`</${escapeRegExp(tagName)}\\s*>`, "giu");
+    close.lastIndex = start + opening.length;
+    const match = close.exec(content);
+    if (!match)
+        invalidDesignResourceHandoff("locator_element_close_missing", detail);
+    const inner = content.slice(start + opening.length, match.index);
+    if (new RegExp(`<${escapeRegExp(tagName)}\\b`, "iu").test(inner))
+        invalidDesignResourceHandoff("locator_nested_same_tag_unsupported", detail);
+    return inner.trim();
+}
+function matchingHtmlTags(content, selector, detail) {
+    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", detail);
+    const result = [];
+    for (const match of content.matchAll(/<([A-Za-z][A-Za-z0-9:-]*)\b([^<>]*)>/gu)) {
+        if (parsed[1] && match[1].toLowerCase() !== parsed[1].toLowerCase())
+            continue;
+        const attributes = htmlAttributes(match[2]);
+        if (parsed[2] && attributes.get("id") !== parsed[2])
+            continue;
+        if (parsed[3]) {
+            const expected = parsed[4] ?? parsed[5] ?? parsed[6];
+            const actual = attributes.get(parsed[3].toLowerCase());
+            if (actual === undefined ||
+                (expected !== undefined && actual !== expected))
+                continue;
+        }
+        result.push({ tag: match[0], attributes: match[2] });
+    }
+    return result;
+}
+export function markdownSection(content, anchor, detail) {
+    const lines = content.split(/\r?\n/u);
+    const slug = (value) => value
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}\s-]/gu, "")
+        .replace(/\s+/gu, "-");
+    const start = lines.findIndex((line) => {
+        const match = /^(#{1,6})\s+(.+)$/u.exec(line);
+        return match ? slug(match[2]) === anchor : false;
+    });
+    if (start < 0)
+        invalidDesignResourceHandoff("locator_not_found", detail);
+    const level = /^(#{1,6})\s/u.exec(lines[start])[1].length;
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const match = /^(#{1,6})\s/u.exec(lines[index]);
+        if (match && match[1].length <= level) {
+            end = index;
+            break;
+        }
+    }
+    return lines.slice(start, end).join("\n").trim();
+}
+export function javascriptExport(content, identifier, detail) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(identifier))
+        invalidDesignResourceHandoff("locator_javascript_export_invalid", detail);
+    const expression = new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${escapeRegExp(identifier)}\\s*=\\s*([^;]+);`, "gu");
+    return uniqueCapture(content, expression, detail).trim();
+}
+export function uniqueCapture(content, expression, detail) {
+    const values = [...content.matchAll(expression)].map((match) => match[1]);
+    if (values.length !== 1)
+        invalidDesignResourceHandoff(values.length ? "locator_ambiguous" : "locator_not_found", detail);
+    return values[0];
+}
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}

package/dist/lib/design-resource-fact-locator-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceTypedLocatorV1 } from "./design-resource-fact-manifest-types.js";
+import { type DesignResource } from "./design-resource-handoff-file-primitives.js";
+export declare function resolveDesignResourceLocatorValue(locator: DesignResourceTypedLocatorV1, resource: DesignResource, bytes: Buffer, label: string): Buffer;

package/dist/lib/design-resource-fact-locator-resolver.js

@@ -0,0 +1,112 @@
+import { isTextResource, } from "./design-resource-handoff-file-primitives.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { cssRuleBody, elementInnerContent, escapeRegExp, htmlAttribute, htmlOpeningTag, javascriptExport, markdownSection, uniqueCapture, } from "./design-resource-fact-locator-extractors.js";
+export function resolveDesignResourceLocatorValue(locator, resource, bytes, label) {
+    const detail = `${label}:${resource.key}:${locator.kind}:${locator.value}`;
+    if (locator.kind === "whole_resource") {
+        if (locator.value !== ".")
+            invalidDesignResourceHandoff("locator_whole_resource_value", detail);
+        return bytes;
+    }
+    if (!isTextResource(resource))
+        invalidDesignResourceHandoff("located_value_text_resource_required", `${detail}:${resource.media_type}`);
+    const content = bytes.toString("utf8");
+    return resolveTextLocator(locator, resource, content, detail);
+}
+function resolveTextLocator(locator, resource, content, detail) {
+    switch (locator.kind) {
+        case "json_pointer":
+            requireMediaType(resource, ["application/json"], detail);
+            return Buffer.from(resolveJsonPointer(content, locator.value, detail));
+        case "css_custom_property":
+            requireMediaType(resource, ["text/css"], detail);
+            return Buffer.from(uniqueCapture(content, new RegExp(`${escapeRegExp(locator.value)}\\s*:\\s*([^;{}]+)`, "gu"), detail).trim());
+        case "css_declaration":
+            return cssDeclaration(content, locator.value, resource, detail);
+        case "css_selector":
+            requireMediaType(resource, ["text/css"], detail);
+            return Buffer.from(cssRuleBody(content, locator.value, detail).trim());
+        case "html_attribute":
+        case "svg_attribute":
+            return markupAttribute(content, locator, resource, detail);
+        case "html_selector":
+        case "svg_selector":
+            requireMarkupMediaType(locator.kind, resource, detail);
+            return Buffer.from(htmlOpeningTag(content, locator.value, detail));
+        case "html_inner_html":
+        case "svg_inner_xml":
+            requireMarkupMediaType(locator.kind, resource, detail);
+            return Buffer.from(elementInnerContent(content, locator.value, detail));
+        case "markdown_anchor":
+            requireMediaType(resource, ["text/markdown"], detail);
+            return Buffer.from(markdownSection(content, locator.value, detail));
+        case "javascript_export":
+            requireMediaType(resource, [
+                "text/javascript",
+                "application/javascript",
+                "text/typescript",
+                "application/typescript",
+            ], detail);
+            return Buffer.from(javascriptExport(content, locator.value, detail));
+        default:
+            invalidDesignResourceHandoff("located_value_locator_unsupported", detail);
+    }
+}
+function cssDeclaration(content, value, resource, detail) {
+    requireMediaType(resource, ["text/css"], detail);
+    const [selector, property] = splitCompoundLocator(value, detail);
+    const body = cssRuleBody(content, selector, detail);
+    return Buffer.from(uniqueCapture(body, new RegExp(`(?:^|;)\\s*${escapeRegExp(property)}\\s*:\\s*([^;]+)`, "gu"), detail).trim());
+}
+function markupAttribute(content, locator, resource, detail) {
+    requireMarkupMediaType(locator.kind, resource, detail);
+    const [selector, attribute] = splitCompoundLocator(locator.value, detail);
+    return Buffer.from(htmlAttribute(content, selector, attribute, detail));
+}
+function requireMarkupMediaType(kind, resource, detail) {
+    requireMediaType(resource, kind.startsWith("svg_")
+        ? ["image/svg+xml"]
+        : ["text/html", "application/xhtml+xml"], detail);
+}
+function resolveJsonPointer(content, pointer, detail) {
+    if (!pointer.startsWith("/"))
+        invalidDesignResourceHandoff("locator_json_pointer_invalid", detail);
+    let current;
+    try {
+        current = JSON.parse(content);
+    }
+    catch {
+        invalidDesignResourceHandoff("locator_json_resource_invalid", detail);
+    }
+    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))
+            invalidDesignResourceHandoff("locator_not_found", detail);
+        current = current[token];
+    }
+    return typeof current === "string" ? current : stableJson(current);
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+function splitCompoundLocator(value, detail) {
+    const parts = value.split("@@");
+    if (parts.length !== 2 || parts.some((part) => !part.trim()))
+        invalidDesignResourceHandoff("locator_compound_value_invalid", detail);
+    return [parts[0].trim(), parts[1].trim()];
+}
+function requireMediaType(resource, expected, detail) {
+    if (!expected.includes(resource.media_type))
+        invalidDesignResourceHandoff("locator_media_type_incompatible", `${detail}:${resource.media_type}`);
+}

package/dist/lib/design-resource-fact-locator-validation.d.ts

@@ -0,0 +1,5 @@
+import type { DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+export { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-resolver.js";
+export { validateDesignResourceValueKind } from "./design-resource-fact-value-validation.js";
+export declare function validateDesignResourceLocatedDigest(located: DesignResourceLocatedDigestV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>, label: string): Buffer;

package/dist/lib/design-resource-fact-locator-validation.js

@@ -0,0 +1,16 @@
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-resolver.js";
+import { sha256Hex } from "./strict-codec.js";
+export { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-resolver.js";
+export { validateDesignResourceValueKind } from "./design-resource-fact-value-validation.js";
+export function validateDesignResourceLocatedDigest(located, resources, contents, label) {
+    const resource = resources.get(located.locator.resource_ref);
+    const bytes = contents.get(located.locator.resource_ref);
+    if (!resource || !bytes)
+        invalidDesignResourceHandoff("located_value_resource_unknown", `${label}:${located.locator.resource_ref}`);
+    const value = resolveDesignResourceLocatorValue(located.locator, resource, bytes, label);
+    const actual = sha256Hex(value);
+    if (actual !== located.sha256)
+        invalidDesignResourceHandoff("located_value_digest_mismatch", `${label}:${located.sha256}:${actual}`);
+    return value;
+}

package/dist/lib/design-resource-fact-manifest-catalog.d.ts

@@ -0,0 +1,4 @@
+import { type DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-manifest-types.js";
+export declare const DESIGN_RESOURCE_STANDARD_PROPERTIES: DesignResourcePropertyDefinitionV1[];
+export declare const DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS: readonly string[];
+export declare const DESIGN_RESOURCE_STANDARD_PROPERTY_BY_KEY: ReadonlyMap<string, DesignResourcePropertyDefinitionV1>;