project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,109 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,5 +0,0 @@
-import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
-import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
-export declare function parseDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffInputV1, contents: Map<string, Buffer>): Map<string, DesignResourceObservableFactManifestV1>;
-export declare function validateDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffV1, contents: Map<string, Buffer>, manifests: Map<string, DesignResourceObservableFactManifestV1>, validateProjection: boolean): void;

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

@@ -1,111 +0,0 @@
-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";
-export function parseDesignResourceFactManifests(parsed, contents) {
-    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    const manifests = new Map();
-    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}`);
-        manifests.set(target.key, manifest);
-    }
-    sameSet([...manifests.keys()], parsed.handoff.targets.map((target) => target.key), "fact_manifest_target_set_mismatch", "handoff");
-    return manifests;
-}
-export function validateDesignResourceFactManifests(parsed, contents, manifests, validateProjection) {
-    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
-    for (const target of parsed.handoff.targets) {
-        const manifest = manifests.get(target.key);
-        if (!manifest)
-            invalid("fact_manifest_target_missing", target.key);
-        validateDesignResourceFactManifestUniverse(manifest, parsed.handoff, target, resources, contents, sourceItems);
-        if (validateProjection)
-            validateManifestProjection(parsed.handoff, target.key, manifest);
-    }
-}
-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, row]));
-    if (handoff.size !== manifestRows.length)
-        invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:count:${handoff.size}:${manifestRows.length}`);
-    for (const manifestRow of manifestRows) {
-        const handoffRow = handoff.get(manifestRow.key);
-        if (!handoffRow)
-            invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:missing:${manifestRow.key}`);
-        if (canonicalJson(handoffRow) !== canonicalJson(manifestRow))
-            invalid(`manifest_handoff_${collection}_row_mismatch`, `${targetKey}:${manifestRow.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,43 +0,0 @@
-import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceOracleCapability } 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;
-    readonly exact_target_visual_pixel_required: true;
-    readonly exact_fact_set_conservation_required: true;
-    readonly design_fact_expression_boundary: true;
-    readonly unsupported_design_fact_blocks: true;
-    readonly control_granularity_is_not_design_fact_granularity: true;
-    readonly public_design_fact_guidance_required: true;
-    readonly design_fact_values_stay_in_canonical_resources: true;
-    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;
-    readonly preflight_is_not_production_conformance: true;
-    readonly unsupported_facts_block: true;
-    readonly control_relations_unchanged: true;
-}>;
-export declare const EXACT_TARGET_FULL_TARGET_METHODS: readonly ["layout_geometry", "visual_pixel"];
-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 DesignResourceOracleCapability[]): boolean;