project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/semantic-fact-condition-shape.js

@@ -0,0 +1,111 @@
+import { SEMANTIC_FACT_DISPOSITIONS } from "./semantic-fact-shape-constants.js";
+import { semanticArray, semanticLiteral, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactAxisValues, parseSemanticFactBoolean, } from "./semantic-fact-value-shape.js";
+export function parseSemanticFactAxisDispositions(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "axis",
+            "standard",
+            "disposition",
+            "outcome_refs",
+            "values",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            axis: semanticStableRef(row.axis, `${itemLabel}.axis`),
+            standard: parseSemanticFactBoolean(row.standard, `${itemLabel}.standard`),
+            disposition: semanticLiteral(row.disposition, SEMANTIC_FACT_DISPOSITIONS, `${itemLabel}.disposition`),
+            outcome_refs: semanticStableRefs(row.outcome_refs, `${itemLabel}.outcome_refs`),
+            values: semanticArray(row.values, `${itemLabel}.values`).map((axisValue, axisIndex) => {
+                const axisLabel = `${itemLabel}.values[${axisIndex}]`;
+                const entry = semanticObject(axisValue, axisLabel, [
+                    "key",
+                    "source_item_refs",
+                    "basis_refs",
+                ]);
+                return {
+                    key: semanticStableRef(entry.key, `${axisLabel}.key`),
+                    source_item_refs: semanticStableRefs(entry.source_item_refs, `${axisLabel}.source_item_refs`),
+                    basis_refs: semanticStableRefs(entry.basis_refs, `${axisLabel}.basis_refs`),
+                };
+            }),
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseSemanticFactConditionRules(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "outcome_ref",
+            "axis_refs",
+            "mode",
+            "condition_refs",
+            "exclusion_refs",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
+            axis_refs: semanticStableRefs(row.axis_refs, `${itemLabel}.axis_refs`),
+            mode: semanticLiteral(row.mode, ["independent", "cross_product", "explicit_meaningful"], `${itemLabel}.mode`),
+            condition_refs: semanticStableRefs(row.condition_refs, `${itemLabel}.condition_refs`),
+            exclusion_refs: semanticStableRefs(row.exclusion_refs, `${itemLabel}.exclusion_refs`),
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseSemanticFactConditions(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "outcome_ref",
+            "axis_values",
+            "source_item_refs",
+            "basis_refs",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
+            axis_values: parseSemanticFactAxisValues(row.axis_values, `${itemLabel}.axis_values`),
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+        };
+    });
+}
+export function parseSemanticFactConditionExclusions(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "outcome_ref",
+            "axis_values",
+            "disposition",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
+            axis_values: parseSemanticFactAxisValues(row.axis_values, `${itemLabel}.axis_values`),
+            disposition: semanticLiteral(row.disposition, ["not_applicable", "decision_required", "unavailable"], `${itemLabel}.disposition`),
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}

package/dist/lib/semantic-fact-input-shape.d.ts

@@ -0,0 +1,34 @@
+export declare function parseSemanticFactCensus(value: unknown, label: string): {
+    key: string;
+    kind: "axis" | "axis_value" | "blocker" | "condition" | "condition_rule" | "custom" | "environment" | "fact" | "fact_cell" | "family" | "input" | "oracle" | "population" | "proof_obligation" | "property" | "relation" | "scope_exclusion" | "subject";
+    locator: {
+        material_ref: string;
+        kind: "api_operation" | "code_symbol" | "custom" | "json_pointer" | "manifest_pointer" | "schema_pointer" | "source_item" | "whole_resource" | "yaml_pointer";
+        value: string;
+    };
+    identity_sha256: string;
+    disposition: "material_with_facts" | "supporting_only";
+    fact_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactInputs(value: unknown, label: string): {
+    key: string;
+    kind: "attachment" | "canonical_spec" | "context" | "delegated_instruction" | "design_resource" | "external_constraint" | "repository_preservation" | "source_item";
+    source_ref: string;
+    sha256: string;
+    disposition: "excluded_by_scope" | "non_ui_material" | "supporting_only" | "ui_design";
+    fact_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactFamilyDispositions(value: unknown, label: string): {
+    key: string;
+    family: string;
+    standard: boolean;
+    disposition: "applicable" | "decision_required" | "not_applicable" | "unavailable";
+    outcome_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];

package/dist/lib/semantic-fact-input-shape.js

@@ -0,0 +1,111 @@
+import { SEMANTIC_FACT_DISPOSITIONS } from "./semantic-fact-shape-constants.js";
+import { semanticArray, semanticLiteral, semanticObject, semanticSha256, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactBoolean, parseSemanticFactLocator, } from "./semantic-fact-value-shape.js";
+export function parseSemanticFactCensus(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "kind",
+            "locator",
+            "identity_sha256",
+            "disposition",
+            "fact_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            kind: semanticLiteral(row.kind, [
+                "input",
+                "scope_exclusion",
+                "family",
+                "subject",
+                "relation",
+                "population",
+                "axis",
+                "axis_value",
+                "condition_rule",
+                "condition",
+                "property",
+                "fact_cell",
+                "fact",
+                "proof_obligation",
+                "oracle",
+                "environment",
+                "blocker",
+                "custom",
+            ], `${itemLabel}.kind`),
+            locator: parseSemanticFactLocator(row.locator, `${itemLabel}.locator`),
+            identity_sha256: semanticSha256(row.identity_sha256, `${itemLabel}.identity_sha256`),
+            disposition: semanticLiteral(row.disposition, ["material_with_facts", "supporting_only"], `${itemLabel}.disposition`),
+            fact_refs: semanticStableRefs(row.fact_refs, `${itemLabel}.fact_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseSemanticFactInputs(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "kind",
+            "source_ref",
+            "sha256",
+            "disposition",
+            "fact_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            kind: semanticLiteral(row.kind, [
+                "source_item",
+                "context",
+                "attachment",
+                "canonical_spec",
+                "repository_preservation",
+                "external_constraint",
+                "delegated_instruction",
+                "design_resource",
+            ], `${itemLabel}.kind`),
+            source_ref: semanticString(row.source_ref, `${itemLabel}.source_ref`),
+            sha256: semanticSha256(row.sha256, `${itemLabel}.sha256`),
+            disposition: semanticLiteral(row.disposition, [
+                "non_ui_material",
+                "ui_design",
+                "supporting_only",
+                "excluded_by_scope",
+            ], `${itemLabel}.disposition`),
+            fact_refs: semanticStableRefs(row.fact_refs, `${itemLabel}.fact_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}
+export function parseSemanticFactFamilyDispositions(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "family",
+            "standard",
+            "disposition",
+            "outcome_refs",
+            "source_item_refs",
+            "basis_refs",
+            "rationale",
+        ]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            family: semanticStableRef(row.family, `${itemLabel}.family`),
+            standard: parseSemanticFactBoolean(row.standard, `${itemLabel}.standard`),
+            disposition: semanticLiteral(row.disposition, SEMANTIC_FACT_DISPOSITIONS, `${itemLabel}.disposition`),
+            outcome_refs: semanticStableRefs(row.outcome_refs, `${itemLabel}.outcome_refs`),
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+        };
+    });
+}

package/dist/lib/semantic-fact-inventory-types.d.ts

@@ -0,0 +1,147 @@
+import type { EvidenceCapabilityV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactDisposition, SemanticFactLocatedValueV1, SemanticFactLocatorKind, SemanticFactValueKind } from "./semantic-fact-base-types.js";
+export interface SemanticFactInputV1 {
+    key: string;
+    kind: "source_item" | "context" | "attachment" | "canonical_spec" | "repository_preservation" | "external_constraint" | "delegated_instruction" | "design_resource";
+    source_ref: string;
+    sha256: string;
+    disposition: "non_ui_material" | "ui_design" | "supporting_only" | "excluded_by_scope";
+    fact_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactCensusEntryV1 {
+    key: string;
+    kind: "input" | "scope_exclusion" | "family" | "subject" | "relation" | "population" | "axis" | "axis_value" | "condition_rule" | "condition" | "property" | "fact_cell" | "fact" | "proof_obligation" | "oracle" | "environment" | "blocker" | "custom";
+    locator: {
+        material_ref: string;
+        kind: SemanticFactLocatorKind;
+        value: string;
+    };
+    identity_sha256: string;
+    disposition: "material_with_facts" | "supporting_only";
+    fact_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactFamilyDispositionV1 {
+    key: string;
+    family: string;
+    standard: boolean;
+    disposition: SemanticFactDisposition;
+    outcome_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactSubjectV1 {
+    key: string;
+    family_ref: string;
+    outcome_ref: string;
+    kind: string;
+    parent_ref: string | null;
+    owner_ref: string | null;
+    source_item_refs: string[];
+    basis_refs: string[];
+}
+export interface SemanticFactRelationV1 {
+    key: string;
+    family_ref: string;
+    outcome_ref: string;
+    kind: string;
+    endpoints: Array<{
+        role: string;
+        unit_ref: string;
+    }>;
+    source_item_refs: string[];
+    basis_refs: string[];
+}
+export interface SemanticFactPopulationV1 {
+    key: string;
+    family_ref: string;
+    outcome_ref: string;
+    kind: "static" | "dynamic";
+    member_unit_refs: string[];
+    universe: SemanticFactLocatedValueV1;
+    enumeration_rule: string;
+    exclusion_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+}
+export interface SemanticFactAxisDispositionV1 {
+    key: string;
+    axis: string;
+    standard: boolean;
+    disposition: SemanticFactDisposition;
+    outcome_refs: string[];
+    values: Array<{
+        key: string;
+        source_item_refs: string[];
+        basis_refs: string[];
+    }>;
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactConditionV1 {
+    key: string;
+    outcome_ref: string;
+    axis_values: Array<{
+        axis_ref: string;
+        value_ref: string;
+    }>;
+    source_item_refs: string[];
+    basis_refs: string[];
+}
+export interface SemanticFactConditionExclusionV1 {
+    key: string;
+    outcome_ref: string;
+    axis_values: Array<{
+        axis_ref: string;
+        value_ref: string;
+    }>;
+    disposition: Exclude<SemanticFactDisposition, "applicable">;
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactConditionRuleV1 {
+    key: string;
+    outcome_ref: string;
+    axis_refs: string[];
+    mode: "independent" | "cross_product" | "explicit_meaningful";
+    condition_refs: string[];
+    exclusion_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactPropertyDispositionV1 {
+    key: string;
+    family_ref: string;
+    property: string;
+    standard: boolean;
+    value_kind: SemanticFactValueKind;
+    required_methods: string[];
+    required_evidence_capabilities: EvidenceCapabilityV2[];
+    applicable_unit_refs: string[];
+    not_applicable_unit_refs: string[];
+    decision_required_unit_refs: string[];
+    unavailable_unit_refs: string[];
+    condition_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}
+export interface SemanticFactCellV1 {
+    key: string;
+    outcome_ref: string;
+    unit_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    disposition: "specified" | "not_applicable" | "decision_required" | "unavailable";
+    fact_ref: string | null;
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}

package/dist/lib/semantic-fact-inventory-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/semantic-fact-manifest-shape.d.ts

@@ -0,0 +1,4 @@
+import { type SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
+export declare function parseSemanticFactManifestYaml(content: string): SemanticFactManifestV1;
+export declare function parseSemanticFactManifestShape(value: unknown): SemanticFactManifestV1;

package/dist/lib/semantic-fact-manifest-shape.js

@@ -0,0 +1,135 @@
+import { parseSemanticFactAxisDispositions, parseSemanticFactConditionExclusions, parseSemanticFactConditionRules, parseSemanticFactConditions, } from "./semantic-fact-condition-shape.js";
+import { parseSemanticFactCensus, parseSemanticFactFamilyDispositions, parseSemanticFactInputs, } from "./semantic-fact-input-shape.js";
+import { SEMANTIC_FACT_MANIFEST_COLLECTIONS, } from "./semantic-fact-types.js";
+import { parseSemanticFactCells, parseSemanticFactPropertyDispositions, } from "./semantic-fact-property-shape.js";
+import { parseSemanticFactProofObligations, parseSemanticFacts, } from "./semantic-fact-proof-shape.js";
+import { semanticArray, semanticInteger, semanticLiteral, semanticNullableSha256, semanticObject, semanticSha256, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactBlockers, parseSemanticFactEnvironments, parseSemanticFactOracles, } from "./semantic-fact-support-shape.js";
+import { parseSemanticFactPopulations, parseSemanticFactRelations, parseSemanticFactSubjects, } from "./semantic-fact-unit-shape.js";
+import { parseStrictYaml } from "./strict-codec.js";
+export { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
+export function parseSemanticFactManifestYaml(content) {
+    return parseSemanticFactManifestShape(parseStrictYaml(content));
+}
+export function parseSemanticFactManifestShape(value) {
+    const label = "semantic_fact_manifest";
+    const root = semanticObject(value, label, [
+        "schema_version",
+        "key",
+        "scope",
+        "inspector",
+        "generation",
+        "inputs",
+        "family_dispositions",
+        "subjects",
+        "relations",
+        "populations",
+        "axis_dispositions",
+        "condition_rules",
+        "conditions",
+        "condition_exclusions",
+        "property_dispositions",
+        "fact_cells",
+        "facts",
+        "proof_obligations",
+        "oracles",
+        "environments",
+        "blockers",
+    ]);
+    const scope = semanticObject(root.scope, `${label}.scope`, [
+        "outcome_refs",
+        "source_item_refs",
+        "exclusions",
+    ]);
+    const inspector = semanticObject(root.inspector, `${label}.inspector`, [
+        "trust",
+        "identity",
+        "version",
+        "implementation_sha256",
+        "capabilities",
+        "traversal",
+        "dynamic_discovery",
+        "census",
+    ]);
+    const generation = semanticObject(root.generation, `${label}.generation`, [
+        "strategy",
+        "sampling",
+        "truncation",
+        "chunk_count",
+        "chunk_indexes",
+        "collections",
+    ]);
+    return {
+        schema_version: semanticLiteral(root.schema_version, ["semantic-fact-manifest-v1"], `${label}.schema_version`),
+        key: semanticStableRef(root.key, `${label}.key`),
+        scope: {
+            outcome_refs: semanticStableRefs(scope.outcome_refs, `${label}.scope.outcome_refs`),
+            source_item_refs: semanticStableRefs(scope.source_item_refs, `${label}.scope.source_item_refs`),
+            exclusions: semanticArray(scope.exclusions, `${label}.scope.exclusions`).map((item, index) => {
+                const itemLabel = `${label}.scope.exclusions[${index}]`;
+                const row = semanticObject(item, itemLabel, [
+                    "key",
+                    "statement",
+                    "affected_refs",
+                    "source_item_refs",
+                    "basis_refs",
+                    "rationale",
+                ]);
+                return {
+                    key: semanticStableRef(row.key, `${itemLabel}.key`),
+                    statement: semanticString(row.statement, `${itemLabel}.statement`),
+                    affected_refs: semanticStableRefs(row.affected_refs, `${itemLabel}.affected_refs`),
+                    source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+                    basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+                    rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+                };
+            }),
+        },
+        inspector: {
+            trust: semanticLiteral(inspector.trust, ["frozen_executable", "named_external_tcb"], `${label}.inspector.trust`),
+            identity: semanticString(inspector.identity, `${label}.inspector.identity`),
+            version: semanticString(inspector.version, `${label}.inspector.version`),
+            implementation_sha256: semanticNullableSha256(inspector.implementation_sha256, `${label}.inspector.implementation_sha256`),
+            capabilities: semanticStableRefs(inspector.capabilities, `${label}.inspector.capabilities`),
+            traversal: semanticLiteral(inspector.traversal, ["complete_enumeration"], `${label}.inspector.traversal`),
+            dynamic_discovery: semanticLiteral(inspector.dynamic_discovery, ["fully_enumerated"], `${label}.inspector.dynamic_discovery`),
+            census: parseSemanticFactCensus(inspector.census, `${label}.inspector.census`),
+        },
+        generation: {
+            strategy: semanticLiteral(generation.strategy, ["complete_explicit"], `${label}.generation.strategy`),
+            sampling: semanticLiteral(generation.sampling, ["forbidden"], `${label}.generation.sampling`),
+            truncation: semanticLiteral(generation.truncation, ["forbidden"], `${label}.generation.truncation`),
+            chunk_count: semanticInteger(generation.chunk_count, `${label}.generation.chunk_count`, 1),
+            chunk_indexes: semanticArray(generation.chunk_indexes, `${label}.generation.chunk_indexes`).map((item, index) => semanticInteger(item, `${label}.generation.chunk_indexes[${index}]`, 0)),
+            collections: semanticArray(generation.collections, `${label}.generation.collections`).map((item, index) => {
+                const itemLabel = `${label}.generation.collections[${index}]`;
+                const row = semanticObject(item, itemLabel, [
+                    "name",
+                    "expected_count",
+                    "identity_sha256",
+                ]);
+                return {
+                    name: semanticLiteral(row.name, SEMANTIC_FACT_MANIFEST_COLLECTIONS, `${itemLabel}.name`),
+                    expected_count: semanticInteger(row.expected_count, `${itemLabel}.expected_count`),
+                    identity_sha256: semanticSha256(row.identity_sha256, `${itemLabel}.identity_sha256`),
+                };
+            }),
+        },
+        inputs: parseSemanticFactInputs(root.inputs, `${label}.inputs`),
+        family_dispositions: parseSemanticFactFamilyDispositions(root.family_dispositions, `${label}.family_dispositions`),
+        subjects: parseSemanticFactSubjects(root.subjects, `${label}.subjects`),
+        relations: parseSemanticFactRelations(root.relations, `${label}.relations`),
+        populations: parseSemanticFactPopulations(root.populations, `${label}.populations`),
+        axis_dispositions: parseSemanticFactAxisDispositions(root.axis_dispositions, `${label}.axis_dispositions`),
+        condition_rules: parseSemanticFactConditionRules(root.condition_rules, `${label}.condition_rules`),
+        conditions: parseSemanticFactConditions(root.conditions, `${label}.conditions`),
+        condition_exclusions: parseSemanticFactConditionExclusions(root.condition_exclusions, `${label}.condition_exclusions`),
+        property_dispositions: parseSemanticFactPropertyDispositions(root.property_dispositions, `${label}.property_dispositions`),
+        fact_cells: parseSemanticFactCells(root.fact_cells, `${label}.fact_cells`),
+        facts: parseSemanticFacts(root.facts, `${label}.facts`),
+        proof_obligations: parseSemanticFactProofObligations(root.proof_obligations, `${label}.proof_obligations`),
+        oracles: parseSemanticFactOracles(root.oracles, `${label}.oracles`),
+        environments: parseSemanticFactEnvironments(root.environments, `${label}.environments`),
+        blockers: parseSemanticFactBlockers(root.blockers, `${label}.blockers`),
+    };
+}

package/dist/lib/semantic-fact-manifest-types.d.ts

@@ -0,0 +1,58 @@
+import type { SemanticFactAxisDispositionV1, SemanticFactCensusEntryV1, SemanticFactCellV1, SemanticFactConditionExclusionV1, SemanticFactConditionRuleV1, SemanticFactConditionV1, SemanticFactFamilyDispositionV1, SemanticFactInputV1, SemanticFactPopulationV1, SemanticFactPropertyDispositionV1, SemanticFactRelationV1, SemanticFactSubjectV1 } from "./semantic-fact-inventory-types.js";
+import type { SemanticFactBlockerV1, SemanticFactEnvironmentV1, SemanticFactOracleV1, SemanticFactProofObligationV1, SemanticFactV1 } from "./semantic-fact-proof-types.js";
+export declare const SEMANTIC_FACT_MANIFEST_COLLECTIONS: readonly ["inputs", "inspector_census", "family_dispositions", "subjects", "relations", "populations", "axis_dispositions", "condition_rules", "conditions", "condition_exclusions", "property_dispositions", "fact_cells", "facts", "proof_obligations", "oracles", "environments", "blockers"];
+export type SemanticFactManifestCollectionName = (typeof SEMANTIC_FACT_MANIFEST_COLLECTIONS)[number];
+export interface SemanticFactManifestV1 {
+    schema_version: "semantic-fact-manifest-v1";
+    key: string;
+    scope: {
+        outcome_refs: string[];
+        source_item_refs: string[];
+        exclusions: Array<{
+            key: string;
+            statement: string;
+            affected_refs: string[];
+            source_item_refs: string[];
+            basis_refs: string[];
+            rationale: string;
+        }>;
+    };
+    inspector: {
+        trust: "frozen_executable" | "named_external_tcb";
+        identity: string;
+        version: string;
+        implementation_sha256: string | null;
+        capabilities: string[];
+        traversal: "complete_enumeration";
+        dynamic_discovery: "fully_enumerated";
+        census: SemanticFactCensusEntryV1[];
+    };
+    generation: {
+        strategy: "complete_explicit";
+        sampling: "forbidden";
+        truncation: "forbidden";
+        chunk_count: number;
+        chunk_indexes: number[];
+        collections: Array<{
+            name: SemanticFactManifestCollectionName;
+            expected_count: number;
+            identity_sha256: string;
+        }>;
+    };
+    inputs: SemanticFactInputV1[];
+    family_dispositions: SemanticFactFamilyDispositionV1[];
+    subjects: SemanticFactSubjectV1[];
+    relations: SemanticFactRelationV1[];
+    populations: SemanticFactPopulationV1[];
+    axis_dispositions: SemanticFactAxisDispositionV1[];
+    condition_rules: SemanticFactConditionRuleV1[];
+    conditions: SemanticFactConditionV1[];
+    condition_exclusions: SemanticFactConditionExclusionV1[];
+    property_dispositions: SemanticFactPropertyDispositionV1[];
+    fact_cells: SemanticFactCellV1[];
+    facts: SemanticFactV1[];
+    proof_obligations: SemanticFactProofObligationV1[];
+    oracles: SemanticFactOracleV1[];
+    environments: SemanticFactEnvironmentV1[];
+    blockers: SemanticFactBlockerV1[];
+}

package/dist/lib/semantic-fact-manifest-types.js

@@ -0,0 +1,19 @@
+export const SEMANTIC_FACT_MANIFEST_COLLECTIONS = [
+    "inputs",
+    "inspector_census",
+    "family_dispositions",
+    "subjects",
+    "relations",
+    "populations",
+    "axis_dispositions",
+    "condition_rules",
+    "conditions",
+    "condition_exclusions",
+    "property_dispositions",
+    "fact_cells",
+    "facts",
+    "proof_obligations",
+    "oracles",
+    "environments",
+    "blockers",
+];

package/dist/lib/semantic-fact-policy-authority.d.ts

@@ -0,0 +1,8 @@
+import { type SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactInspector(manifest: SemanticFactManifestV1): void;
+export declare function validateSemanticFactSourceLineage(manifest: SemanticFactManifestV1): void;
+export declare function semanticFactCollectionIdentity(rows: Array<{
+    key: string;
+}>): string;
+export declare function validateSemanticFactUniqueIdentities(manifest: SemanticFactManifestV1): void;
+export declare function validateSemanticFactGeneration(manifest: SemanticFactManifestV1): void;