project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,159 +0,0 @@
-import { DESIGN_RESOURCE_VARIATION_AXES, } from "./design-resource-fact-manifest-types.js";
-import { atomicAxisValue, contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
-import { array, literal, object, string, } from "./long-task-shape-primitives.js";
-export function parseDesignResourceAxisDispositions(value, label = "design_resource_handoff.axis_dispositions") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "target_ref",
-            "axis",
-            "disposition",
-            "values",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
-            axis: stableKey(row.axis, `${itemLabel}.axis`),
-            disposition: literal(row.disposition, ["applicable", "not_applicable"], `${itemLabel}.disposition`),
-            values: parseAxisValues(row.values, `${itemLabel}.values`),
-            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`),
-        };
-    });
-}
-function parseAxisValues(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "census_refs"]);
-        return {
-            key: atomicAxisValue(row.key, `${itemLabel}.key`),
-            census_refs: stableKeys(row.census_refs, `${itemLabel}.census_refs`),
-        };
-    });
-}
-export function parseDesignResourceConditionExclusions(value, label = "design_resource_handoff.condition_exclusions") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "target_ref",
-            "axis_values",
-            "disposition",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            target_ref: contractKey(row.target_ref, `${itemLabel}.target_ref`),
-            axis_values: parseAxisPairs(row.axis_values, `${itemLabel}.axis_values`),
-            disposition: literal(row.disposition, [
-                "not_applicable",
-                "excluded_by_scope",
-                "decision_required",
-                "unavailable",
-            ], `${itemLabel}.disposition`),
-            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`),
-        };
-    });
-}
-function parseAxisPairs(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["axis_ref", "value_ref"]);
-        return {
-            axis_ref: stableKey(row.axis_ref, `${itemLabel}.axis_ref`),
-            value_ref: atomicAxisValue(row.value_ref, `${itemLabel}.value_ref`),
-        };
-    });
-}
-export function parseDesignResourceVariationAxisDispositions(value, label = "design_resource_handoff.variation_axis_dispositions") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "subject_ref",
-            "axis",
-            "disposition",
-            "values",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            subject_ref: stableKey(row.subject_ref, `${itemLabel}.subject_ref`),
-            axis: literal(row.axis, DESIGN_RESOURCE_VARIATION_AXES, `${itemLabel}.axis`),
-            disposition: literal(row.disposition, ["applicable", "not_applicable"], `${itemLabel}.disposition`),
-            values: parseAxisValues(row.values, `${itemLabel}.values`),
-            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 parseDesignResourceVariationExclusions(value, label = "design_resource_handoff.variation_exclusions") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "subject_ref",
-            "axis_values",
-            "disposition",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            subject_ref: stableKey(row.subject_ref, `${itemLabel}.subject_ref`),
-            axis_values: array(row.axis_values, `${itemLabel}.axis_values`).map((pair, pairIndex) => {
-                const pairLabel = `${itemLabel}.axis_values[${pairIndex}]`;
-                const parsed = object(pair, pairLabel, ["axis_ref", "value_ref"]);
-                return {
-                    axis_ref: literal(parsed.axis_ref, DESIGN_RESOURCE_VARIATION_AXES, `${pairLabel}.axis_ref`),
-                    value_ref: atomicAxisValue(parsed.value_ref, `${pairLabel}.value_ref`),
-                };
-            }),
-            disposition: literal(row.disposition, [
-                "not_applicable",
-                "excluded_by_scope",
-                "decision_required",
-                "unavailable",
-            ], `${itemLabel}.disposition`),
-            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 parseDesignResourceVariations(value, label = "design_resource_handoff.variations") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "subject_ref",
-            "variant",
-            "state",
-            "interaction_phase",
-            "presence_phase",
-            "instance_case",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            subject_ref: stableKey(row.subject_ref, `${itemLabel}.subject_ref`),
-            variant: atomicAxisValue(row.variant, `${itemLabel}.variant`),
-            state: atomicAxisValue(row.state, `${itemLabel}.state`),
-            interaction_phase: atomicAxisValue(row.interaction_phase, `${itemLabel}.interaction_phase`),
-            presence_phase: atomicAxisValue(row.presence_phase, `${itemLabel}.presence_phase`),
-            instance_case: atomicAxisValue(row.instance_case, `${itemLabel}.instance_case`),
-        };
-    });
-}

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

@@ -1,4 +0,0 @@
-import { type DesignResourceAssetBindingV1, type DesignResourceEnvironmentV1, type DesignResourceOracleV1 } from "./design-resource-fact-manifest-types.js";
-export declare function parseDesignResourceOracles(value: unknown, label?: string): DesignResourceOracleV1[];
-export declare function parseDesignResourceEnvironments(value: unknown, label?: string): DesignResourceEnvironmentV1[];
-export declare function parseDesignResourceAssetBindings(value: unknown, label?: string): DesignResourceAssetBindingV1[];

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

@@ -1,59 +0,0 @@
-import { DESIGN_RESOURCE_ORACLE_CAPABILITIES, } from "./design-resource-fact-manifest-types.js";
-import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
-import { contractKeys, sha256, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
-import { array, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
-export function parseDesignResourceOracles(value, label = "design_resource_handoff.oracles") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "trust",
-            "identity",
-            "version",
-            "sha256",
-            "capability_refs",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            trust: literal(row.trust, ["frozen_executable", "named_external_tcb"], `${itemLabel}.trust`),
-            identity: string(row.identity, `${itemLabel}.identity`),
-            version: string(row.version, `${itemLabel}.version`),
-            sha256: nullable(row.sha256, (item) => sha256(item, `${itemLabel}.sha256`)),
-            capability_refs: array(row.capability_refs, `${itemLabel}.capability_refs`).map((capability, capabilityIndex) => literal(capability, DESIGN_RESOURCE_ORACLE_CAPABILITIES, `${itemLabel}.capability_refs[${capabilityIndex}]`)),
-        };
-    });
-}
-export function parseDesignResourceEnvironments(value, label = "design_resource_handoff.environments") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "identity", "definition"]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            identity: string(row.identity, `${itemLabel}.identity`),
-            definition: parseDesignResourceLocatedDigest(row.definition, `${itemLabel}.definition`),
-        };
-    });
-}
-export function parseDesignResourceAssetBindings(value, label = "design_resource_handoff.asset_bindings") {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "asset_subject_ref",
-            "resource_ref",
-            "target_refs",
-            "condition_refs",
-            "fact_refs",
-            "consumer_subject_refs",
-        ]);
-        return {
-            key: stableKey(row.key, `${itemLabel}.key`),
-            asset_subject_ref: stableKey(row.asset_subject_ref, `${itemLabel}.asset_subject_ref`),
-            resource_ref: stableKey(row.resource_ref, `${itemLabel}.resource_ref`),
-            target_refs: contractKeys(row.target_refs, `${itemLabel}.target_refs`),
-            condition_refs: contractKeys(row.condition_refs, `${itemLabel}.condition_refs`),
-            fact_refs: stableKeys(row.fact_refs, `${itemLabel}.fact_refs`),
-            consumer_subject_refs: stableKeys(row.consumer_subject_refs, `${itemLabel}.consumer_subject_refs`),
-        };
-    });
-}

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

@@ -1,4 +0,0 @@
-import { type DesignResourceFactCellV1, type DesignResourceProofObligationV1, type DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-manifest-types.js";
-export declare function parseDesignResourceProperties(value: unknown, label?: string): DesignResourcePropertyDefinitionV1[];
-export declare function parseDesignResourceFactCells(value: unknown, label?: string): DesignResourceFactCellV1[];
-export declare function parseDesignResourceProofObligations(value: unknown, label?: string): DesignResourceProofObligationV1[];

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;