project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/design-resource-fact-manifest-shape-facts.js

@@ -0,0 +1,109 @@
+import { DESIGN_RESOURCE_COMPARATORS, DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, DESIGN_RESOURCE_PROPERTY_FAMILIES, 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_VERIFICATION_METHODS, } from "./design-resource-handoff-types.js";
+import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, boolean, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceProperties(value, label = "design_resource_handoff.properties") {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "family",
+            "dimension",
+            "value_kind",
+            "required_methods",
+            "standard",
+            "inspector_capability_refs",
+            "census_refs",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            family: literal(row.family, DESIGN_RESOURCE_PROPERTY_FAMILIES, `${itemLabel}.family`),
+            dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${itemLabel}.dimension`),
+            value_kind: literal(row.value_kind, DESIGN_RESOURCE_VALUE_KINDS, `${itemLabel}.value_kind`),
+            required_methods: array(row.required_methods, `${itemLabel}.required_methods`).map((method, methodIndex) => literal(method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.required_methods[${methodIndex}]`)),
+            standard: boolean(row.standard, `${itemLabel}.standard`),
+            inspector_capability_refs: array(row.inspector_capability_refs, `${itemLabel}.inspector_capability_refs`).map((capability, capabilityIndex) => literal(capability, DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, `${itemLabel}.inspector_capability_refs[${capabilityIndex}]`)),
+            census_refs: stableKeys(row.census_refs, `${itemLabel}.census_refs`),
+        };
+    });
+}
+export function parseDesignResourceFactCells(value, label = "design_resource_handoff.fact_cells") {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "subject_ref",
+            "target_ref",
+            "condition_ref",
+            "variation_ref",
+            "property_ref",
+            "disposition",
+            "fact_ref",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            subject_ref: stableKey(row.subject_ref, `${itemLabel}.subject_ref`),
+            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
+            condition_ref: contractKey(row.condition_ref, `${itemLabel}.condition_ref`),
+            variation_ref: stableKey(row.variation_ref, `${itemLabel}.variation_ref`),
+            property_ref: stableKey(row.property_ref, `${itemLabel}.property_ref`),
+            disposition: literal(row.disposition, [
+                "covered",
+                "not_applicable",
+                "excluded_by_scope",
+                "decision_required",
+                "unavailable",
+            ], `${itemLabel}.disposition`),
+            fact_ref: nullable(row.fact_ref, (factRef) => stableKey(factRef, `${itemLabel}.fact_ref`)),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: stableKeys(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: string(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseDesignResourceProofObligations(value, label = "design_resource_handoff.proof_obligations") {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "fact_ref",
+            "method",
+            "comparison",
+            "oracle_ref",
+            "environment_ref",
+        ]);
+        const comparison = object(row.comparison, `${itemLabel}.comparison`, [
+            "comparator",
+            "mode",
+            "parameters",
+            "tolerance",
+            "mask",
+        ]);
+        const comparator = parseComparator(comparison.comparator, `${itemLabel}.comparison.comparator`);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            fact_ref: stableKey(row.fact_ref, `${itemLabel}.fact_ref`),
+            method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.method`),
+            comparison: {
+                comparator,
+                mode: literal(comparison.mode, ["exact", "tolerance"], `${itemLabel}.comparison.mode`),
+                parameters: parseDesignResourceLocatedDigest(comparison.parameters, `${itemLabel}.comparison.parameters`),
+                tolerance: nullable(comparison.tolerance, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.tolerance`)),
+                mask: nullable(comparison.mask, (entry) => parseDesignResourceLocatedDigest(entry, `${itemLabel}.comparison.mask`)),
+            },
+            oracle_ref: stableKey(row.oracle_ref, `${itemLabel}.oracle_ref`),
+            environment_ref: stableKey(row.environment_ref, `${itemLabel}.environment_ref`),
+        };
+    });
+}
+function parseComparator(value, label) {
+    const comparator = string(value, label);
+    if (!DESIGN_RESOURCE_COMPARATORS.includes(comparator) &&
+        !/^custom\.[a-z0-9][a-z0-9._-]*$/u.test(comparator))
+        throw new Error(`design_resource_handoff_invalid:${label}:must be a standard comparator or custom.*`);
+    return comparator;
+}

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

@@ -0,0 +1,5 @@
+import { type DesignResourceDesignSystemSnapshotV1, type DesignResourceInspectorV1, type DesignResourceLineageNodeV1, type DesignResourceManifestGenerationV1 } from "./design-resource-fact-manifest-types.js";
+export declare function parseDesignResourceLineageNodes(value: unknown, label?: string): DesignResourceLineageNodeV1[];
+export declare function parseDesignResourceFactManifestInspector(value: unknown, label: string): DesignResourceInspectorV1;
+export declare function parseDesignResourceManifestDesignSystem(value: unknown, label: string): DesignResourceDesignSystemSnapshotV1;
+export declare function parseDesignResourceFactManifestGeneration(value: unknown, label: string): DesignResourceManifestGenerationV1;

package/dist/lib/design-resource-fact-manifest-shape-inspector.js

@@ -0,0 +1,144 @@
+import { DESIGN_RESOURCE_CENSUS_KINDS, DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, DESIGN_RESOURCE_LINEAGE_NODE_KINDS, DESIGN_RESOURCE_MANIFEST_COLLECTIONS, } from "./design-resource-fact-manifest-types.js";
+import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
+import { DESIGN_RESOURCE_LOCATOR_KINDS } from "./design-resource-handoff-types.js";
+import { nonnegativeInteger, positiveInteger, sha256, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, nullable, object, repositoryFile, string, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceLineageNodes(value, label = "design_resource_handoff.lineage_nodes") {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "kind",
+            "predecessor_refs",
+            "value",
+            "census_refs",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            kind: literal(row.kind, DESIGN_RESOURCE_LINEAGE_NODE_KINDS, `${itemLabel}.kind`),
+            predecessor_refs: stableKeys(row.predecessor_refs, `${itemLabel}.predecessor_refs`),
+            value: parseDesignResourceLocatedDigest(row.value, `${itemLabel}.value`),
+            census_refs: stableKeys(row.census_refs, `${itemLabel}.census_refs`),
+        };
+    });
+}
+export function parseDesignResourceFactManifestInspector(value, label) {
+    const row = object(value, label, [
+        "trust",
+        "identity",
+        "version",
+        "implementation_sha256",
+        "capability_refs",
+        "entry_resource_ref",
+        "input_resources",
+        "traversal",
+        "dynamic_discovery",
+        "census",
+    ]);
+    return {
+        trust: literal(row.trust, ["frozen_executable", "named_external_tcb"], `${label}.trust`),
+        identity: string(row.identity, `${label}.identity`),
+        version: string(row.version, `${label}.version`),
+        implementation_sha256: nullable(row.implementation_sha256, (item) => sha256(item, `${label}.implementation_sha256`)),
+        capability_refs: array(row.capability_refs, `${label}.capability_refs`).map((item, index) => literal(item, DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, `${label}.capability_refs[${index}]`)),
+        entry_resource_ref: stableKey(row.entry_resource_ref, `${label}.entry_resource_ref`),
+        input_resources: array(row.input_resources, `${label}.input_resources`).map((item, index) => {
+            const itemLabel = `${label}.input_resources[${index}]`;
+            const input = object(item, itemLabel, [
+                "resource_ref",
+                "path",
+                "sha256",
+            ]);
+            return {
+                resource_ref: stableKey(input.resource_ref, `${itemLabel}.resource_ref`),
+                path: repositoryFile(input.path, `${itemLabel}.path`),
+                sha256: sha256(input.sha256, `${itemLabel}.sha256`),
+            };
+        }),
+        traversal: literal(row.traversal, ["complete_enumeration"], `${label}.traversal`),
+        dynamic_discovery: literal(row.dynamic_discovery, ["fully_enumerated"], `${label}.dynamic_discovery`),
+        census: parseInspectorCensus(row.census, `${label}.census`),
+    };
+}
+function parseInspectorCensus(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const entry = object(item, itemLabel, [
+            "key",
+            "kind",
+            "resource_ref",
+            "locator",
+            "disposition",
+            "fact_refs",
+            "fact_cell_refs",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        const locator = object(entry.locator, `${itemLabel}.locator`, [
+            "kind",
+            "value",
+        ]);
+        return {
+            key: stableKey(entry.key, `${itemLabel}.key`),
+            kind: literal(entry.kind, DESIGN_RESOURCE_CENSUS_KINDS, `${itemLabel}.kind`),
+            resource_ref: stableKey(entry.resource_ref, `${itemLabel}.resource_ref`),
+            locator: {
+                kind: literal(locator.kind, DESIGN_RESOURCE_LOCATOR_KINDS, `${itemLabel}.locator.kind`),
+                value: string(locator.value, `${itemLabel}.locator.value`),
+            },
+            disposition: literal(entry.disposition, ["covered", "non_material"], `${itemLabel}.disposition`),
+            fact_refs: stableKeys(entry.fact_refs, `${itemLabel}.fact_refs`),
+            fact_cell_refs: stableKeys(entry.fact_cell_refs, `${itemLabel}.fact_cell_refs`),
+            source_item_refs: sourceItemKeys(entry.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: stableKeys(entry.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: string(entry.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseDesignResourceManifestDesignSystem(value, label) {
+    const row = object(value, label, [
+        "disposition",
+        "id",
+        "revision",
+        "resource_ref",
+        "sha256",
+    ]);
+    return {
+        disposition: literal(row.disposition, ["used", "not_applicable"], `${label}.disposition`),
+        id: string(row.id, `${label}.id`),
+        revision: string(row.revision, `${label}.revision`),
+        resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
+        sha256: sha256(row.sha256, `${label}.sha256`),
+    };
+}
+export function parseDesignResourceFactManifestGeneration(value, label) {
+    const row = object(value, label, [
+        "strategy",
+        "sampling",
+        "truncation",
+        "chunk_count",
+        "chunk_indexes",
+        "collections",
+    ]);
+    return {
+        strategy: literal(row.strategy, ["complete_explicit"], `${label}.strategy`),
+        sampling: literal(row.sampling, ["forbidden"], `${label}.sampling`),
+        truncation: literal(row.truncation, ["forbidden"], `${label}.truncation`),
+        chunk_count: positiveInteger(row.chunk_count, `${label}.chunk_count`),
+        chunk_indexes: array(row.chunk_indexes, `${label}.chunk_indexes`).map((item, index) => nonnegativeInteger(item, `${label}.chunk_indexes[${index}]`)),
+        collections: array(row.collections, `${label}.collections`).map((item, index) => {
+            const itemLabel = `${label}.collections[${index}]`;
+            const collection = object(item, itemLabel, [
+                "name",
+                "expected_count",
+                "identity_sha256",
+            ]);
+            return {
+                name: literal(collection.name, DESIGN_RESOURCE_MANIFEST_COLLECTIONS, `${itemLabel}.name`),
+                expected_count: nonnegativeInteger(collection.expected_count, `${itemLabel}.expected_count`),
+                identity_sha256: sha256(collection.identity_sha256, `${itemLabel}.identity_sha256`),
+            };
+        }),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+export * from "./design-resource-fact-manifest-shape-inspector.js";
+export * from "./design-resource-fact-manifest-shape-axes.js";
+export * from "./design-resource-fact-manifest-shape-facts.js";
+export * from "./design-resource-fact-manifest-shape-evidence.js";
+export declare function parseDesignResourceFactManifestJson(content: string): DesignResourceObservableFactManifestV1;
+export declare function parseDesignResourceFactManifestShape(value: unknown): DesignResourceObservableFactManifestV1;

package/dist/lib/design-resource-fact-manifest-shape.js

@@ -0,0 +1,75 @@
+import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, } from "./design-resource-handoff-shape-evidence.js";
+import { parseDesignResourceHandoffConditions, parseDesignResourceHandoffSubjects, } from "./design-resource-handoff-shape-structure.js";
+import { contractKey } from "./design-resource-handoff-shape-primitives.js";
+import { literal, object } from "./long-task-shape-primitives.js";
+import { parseDesignResourceFactManifestGeneration, parseDesignResourceFactManifestInspector, parseDesignResourceLineageNodes, parseDesignResourceManifestDesignSystem, } from "./design-resource-fact-manifest-shape-inspector.js";
+import { parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape-axes.js";
+import { parseDesignResourceFactCells, parseDesignResourceProofObligations, parseDesignResourceProperties, } from "./design-resource-fact-manifest-shape-facts.js";
+import { parseDesignResourceAssetBindings, parseDesignResourceEnvironments, parseDesignResourceOracles, } from "./design-resource-fact-manifest-shape-evidence.js";
+export * from "./design-resource-fact-manifest-shape-inspector.js";
+export * from "./design-resource-fact-manifest-shape-axes.js";
+export * from "./design-resource-fact-manifest-shape-facts.js";
+export * from "./design-resource-fact-manifest-shape-evidence.js";
+export function parseDesignResourceFactManifestJson(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`design_resource_fact_manifest_invalid:json:${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseDesignResourceFactManifestShape(value);
+}
+export function parseDesignResourceFactManifestShape(value) {
+    const label = "design_resource_fact_manifest";
+    const root = object(value, label, [
+        "schema_version",
+        "scope_key",
+        "target_key",
+        "inspector",
+        "design_system",
+        "generation",
+        "axis_dispositions",
+        "condition_exclusions",
+        "conditions",
+        "subjects",
+        "variation_axis_dispositions",
+        "variation_exclusions",
+        "variations",
+        "properties",
+        "lineage_nodes",
+        "fact_cells",
+        "facts",
+        "evidence",
+        "proof_obligations",
+        "oracles",
+        "environments",
+        "asset_bindings",
+        "acceptance_blockers",
+    ]);
+    return {
+        schema_version: literal(root.schema_version, ["design-resource-observable-fact-manifest-v1"], `${label}.schema_version`),
+        scope_key: contractKey(root.scope_key, `${label}.scope_key`),
+        target_key: contractKey(root.target_key, `${label}.target_key`),
+        inspector: parseDesignResourceFactManifestInspector(root.inspector, `${label}.inspector`),
+        design_system: parseDesignResourceManifestDesignSystem(root.design_system, `${label}.design_system`),
+        generation: parseDesignResourceFactManifestGeneration(root.generation, `${label}.generation`),
+        axis_dispositions: parseDesignResourceAxisDispositions(root.axis_dispositions, `${label}.axis_dispositions`),
+        condition_exclusions: parseDesignResourceConditionExclusions(root.condition_exclusions, `${label}.condition_exclusions`),
+        conditions: parseDesignResourceHandoffConditions(root.conditions),
+        subjects: parseDesignResourceHandoffSubjects(root.subjects),
+        variation_axis_dispositions: parseDesignResourceVariationAxisDispositions(root.variation_axis_dispositions, `${label}.variation_axis_dispositions`),
+        variation_exclusions: parseDesignResourceVariationExclusions(root.variation_exclusions, `${label}.variation_exclusions`),
+        variations: parseDesignResourceVariations(root.variations, `${label}.variations`),
+        properties: parseDesignResourceProperties(root.properties, `${label}.properties`),
+        lineage_nodes: parseDesignResourceLineageNodes(root.lineage_nodes, `${label}.lineage_nodes`),
+        fact_cells: parseDesignResourceFactCells(root.fact_cells, `${label}.fact_cells`),
+        facts: parseDesignResourceHandoffFacts(root.facts),
+        evidence: parseDesignResourceHandoffEvidence(root.evidence),
+        proof_obligations: parseDesignResourceProofObligations(root.proof_obligations, `${label}.proof_obligations`),
+        oracles: parseDesignResourceOracles(root.oracles, `${label}.oracles`),
+        environments: parseDesignResourceEnvironments(root.environments, `${label}.environments`),
+        asset_bindings: parseDesignResourceAssetBindings(root.asset_bindings, `${label}.asset_bindings`),
+        acceptance_blockers: parseDesignResourceHandoffBlockers(root.acceptance_blockers),
+    };
+}

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

@@ -0,0 +1,3 @@
+export * from "./design-resource-fact-enums.js";
+export * from "./design-resource-fact-types.js";
+export * from "./design-resource-fact-manifest-model.js";

package/dist/lib/design-resource-fact-manifest-types.js

@@ -0,0 +1,3 @@
+export * from "./design-resource-fact-enums.js";
+export * from "./design-resource-fact-types.js";
+export * from "./design-resource-fact-manifest-model.js";

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

@@ -0,0 +1,5 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffTargetV1, DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export { conditionAxisValue, manifestIdentityDigest, } from "./design-resource-fact-universe-helpers.js";
+export declare function validateDesignResourceFactManifestUniverse(manifest: DesignResourceObservableFactManifestV1, handoff: DesignResourceHandoffV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>, sourceItems: Map<string, string>): void;

package/dist/lib/design-resource-fact-manifest-universe.js

@@ -0,0 +1,50 @@
+import { validateManifestInspector, validateManifestLineageNodes, } from "./design-resource-fact-universe-inspector.js";
+import { validateManifestDesignSystem, validateManifestSubjects, } from "./design-resource-fact-universe-subjects.js";
+import { validateManifestConditionUniverse } from "./design-resource-fact-universe-conditions.js";
+import { validateManifestVariationUniverse } from "./design-resource-fact-universe-variations.js";
+import { validateManifestCensusOwnership, validateManifestFactCells, validateManifestPropertyCatalog, } from "./design-resource-fact-universe-catalog.js";
+import { validateManifestFacts } from "./design-resource-fact-universe-facts.js";
+import { validateManifestProofAndEvidence } from "./design-resource-fact-universe-proof.js";
+import { validateManifestAssets, validateManifestGeneration, } from "./design-resource-fact-universe-assets.js";
+import { unique } from "./design-resource-fact-universe-helpers.js";
+export { conditionAxisValue, manifestIdentityDigest, } from "./design-resource-fact-universe-helpers.js";
+export function validateDesignResourceFactManifestUniverse(manifest, handoff, target, resources, contents, sourceItems) {
+    validateUniqueManifestCollections(manifest);
+    const census = new Map(manifest.inspector.census.map((item) => [item.key, item]));
+    validateManifestInspector(manifest, handoff, target, resources, contents, sourceItems);
+    validateManifestDesignSystem(manifest, handoff, target, resources);
+    validateManifestSubjects(manifest, census);
+    validateManifestConditionUniverse(manifest, census, sourceItems);
+    validateManifestVariationUniverse(manifest, census, sourceItems);
+    validateManifestPropertyCatalog(manifest, census);
+    validateManifestLineageNodes(manifest, census, resources, contents);
+    validateManifestCensusOwnership(manifest);
+    validateManifestFactCells(manifest, sourceItems, census);
+    validateManifestFacts(manifest, handoff, resources, contents, sourceItems);
+    validateManifestProofAndEvidence(manifest, target, resources, contents);
+    validateManifestAssets(manifest, resources);
+    validateManifestGeneration(manifest);
+}
+function validateUniqueManifestCollections(manifest) {
+    for (const [name, rows] of [
+        ["inspector_census", manifest.inspector.census],
+        ["axis_disposition", manifest.axis_dispositions],
+        ["condition_exclusion", manifest.condition_exclusions],
+        ["condition", manifest.conditions],
+        ["subject", manifest.subjects],
+        ["variation_axis_disposition", manifest.variation_axis_dispositions],
+        ["variation_exclusion", manifest.variation_exclusions],
+        ["variation", manifest.variations],
+        ["property", manifest.properties],
+        ["lineage_node", manifest.lineage_nodes],
+        ["fact_cell", manifest.fact_cells],
+        ["fact", manifest.facts],
+        ["evidence", manifest.evidence],
+        ["proof_obligation", manifest.proof_obligations],
+        ["oracle", manifest.oracles],
+        ["environment", manifest.environments],
+        ["asset_binding", manifest.asset_bindings],
+        ["acceptance_blocker", manifest.acceptance_blockers],
+    ])
+        unique(rows.map((item) => item.key), `manifest_${name}_key_duplicate`);
+}

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

@@ -0,0 +1,3 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function loadAndValidateDesignResourceFactManifests(repository: string, parsed: ParsedDesignResourceHandoffV1): Promise<Map<string, DesignResourceObservableFactManifestV1>>;

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

@@ -0,0 +1,106 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceFactManifestJson } from "./design-resource-fact-manifest-shape.js";
+import { validateDesignResourceFactManifestUniverse } from "./design-resource-fact-manifest-universe.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+export async function loadAndValidateDesignResourceFactManifests(repository, parsed) {
+    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
+    const contents = new Map();
+    for (const resource of parsed.handoff.resources) {
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
+        contents.set(resource.key, await readFile(file));
+    }
+    const manifests = new Map();
+    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
+    for (const target of parsed.handoff.targets) {
+        const manifestRef = target.source_profile.fact_manifest_resource_ref;
+        const manifestResource = resources.get(manifestRef);
+        if (!manifestResource)
+            invalid("fact_manifest_resource_unknown", `${target.key}:${manifestRef}`);
+        if (manifestResource.media_type !== "application/json")
+            invalid("fact_manifest_media_type_invalid", `${target.key}:${manifestResource.media_type}`);
+        if (manifestResource.role !== "supporting")
+            invalid("fact_manifest_supporting_role_required", `${target.key}:${manifestResource.role}`);
+        if (target.source_profile.entry_resource_ref === manifestRef)
+            invalid("fact_manifest_must_not_be_entry", target.key);
+        if (!target.source_profile.dependency_resource_refs.includes(manifestRef))
+            invalid("fact_manifest_dependency_required", target.key);
+        const manifest = parseDesignResourceFactManifestJson(contents.get(manifestRef).toString("utf8"));
+        if (manifests.has(manifest.target_key))
+            invalid("fact_manifest_target_duplicate", manifest.target_key);
+        if (manifest.target_key !== target.key ||
+            manifest.scope_key !== parsed.handoff.scope.key)
+            invalid("fact_manifest_identity_mismatch", `${target.key}:${manifest.scope_key}:${manifest.target_key}`);
+        validateDesignResourceFactManifestUniverse(manifest, parsed.handoff, target, resources, contents, sourceItems);
+        validateManifestProjection(parsed.handoff, target.key, manifest);
+        manifests.set(target.key, manifest);
+    }
+    sameSet([...manifests.keys()], parsed.handoff.targets.map((target) => target.key), "fact_manifest_target_set_mismatch", "handoff");
+    return manifests;
+}
+function validateManifestProjection(handoff, targetKey, manifest) {
+    const target = handoff.targets.find((item) => item.key === targetKey);
+    const targetConditions = new Set(target.condition_refs);
+    const targetSubjects = new Set(handoff.subjects
+        .filter((subject) => subject.target_refs.includes(targetKey))
+        .map((subject) => subject.key));
+    const targetVariations = new Set(handoff.variations
+        .filter((variation) => targetSubjects.has(variation.subject_ref))
+        .map((variation) => variation.key));
+    const targetFacts = handoff.facts.filter((fact) => fact.target_ref === targetKey);
+    const targetFactRefs = new Set(targetFacts.map((fact) => fact.key));
+    const targetEvidenceRefs = new Set(targetFacts.flatMap((fact) => fact.evidence_refs));
+    const targetProof = handoff.proof_obligations.filter((proof) => targetFactRefs.has(proof.fact_ref));
+    const targetOracleRefs = new Set(targetProof.map((proof) => proof.oracle_ref));
+    const targetEnvironmentRefs = new Set(targetProof.map((proof) => proof.environment_ref));
+    exactRows(handoff.axis_dispositions.filter((row) => row.target_ref === targetKey), manifest.axis_dispositions, "axis_dispositions", targetKey);
+    exactRows(handoff.condition_exclusions.filter((row) => row.target_ref === targetKey), manifest.condition_exclusions, "condition_exclusions", targetKey);
+    exactRows(handoff.conditions.filter((row) => targetConditions.has(row.key)), manifest.conditions, "conditions", targetKey);
+    exactRows(handoff.subjects.filter((row) => targetSubjects.has(row.key)), manifest.subjects, "subjects", targetKey);
+    exactRows(handoff.variation_axis_dispositions.filter((row) => targetSubjects.has(row.subject_ref)), manifest.variation_axis_dispositions, "variation_axis_dispositions", targetKey);
+    exactRows(handoff.variation_exclusions.filter((row) => targetSubjects.has(row.subject_ref)), manifest.variation_exclusions, "variation_exclusions", targetKey);
+    exactRows(handoff.variations.filter((row) => targetVariations.has(row.key)), manifest.variations, "variations", targetKey);
+    exactRows(handoff.properties, manifest.properties, "properties", targetKey);
+    const targetLineageRefs = new Set(targetFacts.flatMap((fact) => [
+        ...fact.lineage.token_chain_refs,
+        ...fact.lineage.override_chain_refs,
+    ]));
+    exactRows(handoff.lineage_nodes.filter((row) => targetLineageRefs.has(row.key)), manifest.lineage_nodes, "lineage_nodes", targetKey);
+    exactRows(handoff.fact_cells.filter((row) => row.target_ref === targetKey), manifest.fact_cells, "fact_cells", targetKey);
+    exactRows(targetFacts, manifest.facts, "facts", targetKey);
+    exactRows(handoff.evidence.filter((row) => targetEvidenceRefs.has(row.key)), manifest.evidence, "evidence", targetKey);
+    exactRows(targetProof, manifest.proof_obligations, "proof_obligations", targetKey);
+    exactRows(handoff.oracles.filter((row) => targetOracleRefs.has(row.key)), manifest.oracles, "oracles", targetKey);
+    exactRows(handoff.environments.filter((row) => targetEnvironmentRefs.has(row.key)), manifest.environments, "environments", targetKey);
+    exactRows(handoff.asset_bindings.filter((row) => row.target_refs.includes(targetKey)), manifest.asset_bindings, "asset_bindings", targetKey);
+    exactRows(handoff.acceptance_blockers.filter((row) => row.target_refs.includes(targetKey)), manifest.acceptance_blockers, "acceptance_blockers", targetKey);
+}
+function exactRows(handoffRows, manifestRows, collection, targetKey) {
+    const handoff = new Map(handoffRows.map((row) => [row.key, canonicalJson(row)]));
+    const manifest = new Map(manifestRows.map((row) => [row.key, canonicalJson(row)]));
+    sameSet([...handoff.keys()], [...manifest.keys()], `manifest_handoff_${collection}_set_mismatch`, targetKey);
+    for (const [key, value] of manifest)
+        if (handoff.get(key) !== value)
+            invalid(`manifest_handoff_${collection}_row_mismatch`, `${targetKey}:${key}`);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+function sameSet(actual, expected, code, detail) {
+    const left = [...new Set(actual)].sort();
+    const right = [...new Set(expected)].sort();
+    if (left.length !== right.length ||
+        left.some((item, index) => item !== right[index]))
+        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}
+function invalid(code, detail) {
+    invalidDesignResourceHandoff(code, detail);
+}

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

@@ -1,4 +1,5 @@
 import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { DesignResourceInspectorCapability } from "./design-resource-fact-manifest-types.js";
 export declare const DESIGN_RESOURCE_FACT_INVARIANTS: Readonly<{
     readonly complete_observable_design_fact_delivery: true;
     readonly resource_fact_inventory_closure_required: true;
@@ -12,6 +13,20 @@ export declare const DESIGN_RESOURCE_FACT_INVARIANTS: Readonly<{
     readonly no_second_design_fact_authority: true;
     readonly fact_inventory_required: true;
     readonly contract_evidence_fact_binding_required: true;
+    readonly authoring_obligation_universe_precedes_generation: true;
+    readonly frozen_inspector_census_required: true;
+    readonly first_class_condition_variation_property_axes_required: true;
+    readonly atomic_fact_cell_identity_required: true;
+    readonly expected_canonical_handoff_fact_universe_equality_required: true;
+    readonly aggregate_state_or_condition_labels_forbidden: true;
+    readonly complete_generation_without_sampling_or_truncation_required: true;
+    readonly fact_identity_and_proof_method_obligation_separation_required: true;
+    readonly property_required_methods_cannot_be_weakened: true;
+    readonly design_system_effective_value_lineage_required: true;
+    readonly dynamic_relation_and_asset_fact_closure_required: true;
+    readonly per_fact_expected_comparison_authority_required: true;
+    readonly per_fact_current_result_required: true;
+    readonly protected_fact_observation_redaction_required: true;
     readonly selected_design_fact_antidegradation_required: true;
     readonly design_fact_distribution_context_cost: true;
     readonly forbidden_design_fact_shortcuts_absent: true;
@@ -23,3 +38,6 @@ export declare const EXACT_TARGET_FULL_TARGET_METHODS: readonly ["layout_geometr
 export declare function assertDesignResourceFactPolicyEnabled(): void;
 export declare function designFactMethodIsCompatible(dimension: DesignResourceDimension, method: DesignResourceVerificationMethod): boolean;
 export declare function designFactEvidenceIsCompatible(dimension: DesignResourceDimension, kind: DesignResourceEvidenceKind): boolean;
+export declare function designFactEvidenceSupportsMethod(method: DesignResourceVerificationMethod, kind: DesignResourceEvidenceKind): boolean;
+export declare function designFactComparatorSupportsMethod(method: DesignResourceVerificationMethod, comparator: string): boolean;
+export declare function designFactOracleSupportsMethod(method: DesignResourceVerificationMethod, capabilities: readonly DesignResourceInspectorCapability[]): boolean;