project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/semantic-fact-compact-parser.js

@@ -0,0 +1,168 @@
+import { semanticArray, semanticFail, semanticInteger, semanticLiteral, semanticObject, semanticSha256, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { SEMANTIC_COMPACT_CAPACITY_FIELDS, SEMANTIC_COMPACT_CATALOG_COLLECTIONS, plainSemanticCompactObject, resolveSemanticCompactSelectors, } from "./semantic-fact-compact-support.js";
+export function parseSemanticCompactCapacity(value, label) {
+    const row = semanticObject(value, label, [
+        "theoretical_ground_universe",
+        "measured",
+        "maximum",
+    ]);
+    semanticLiteral(row.theoretical_ground_universe, ["not_materialized"], `${label}.theoretical_ground_universe`);
+    return {
+        measured: parseCapacityCounts(row.measured, `${label}.measured`),
+        maximum: parseCapacityCounts(row.maximum, `${label}.maximum`),
+    };
+}
+function parseCapacityCounts(value, label) {
+    const row = semanticObject(value, label, [
+        ...SEMANTIC_COMPACT_CAPACITY_FIELDS,
+    ]);
+    return Object.fromEntries(SEMANTIC_COMPACT_CAPACITY_FIELDS.map((field) => [
+        field,
+        semanticInteger(row[field], `${label}.${field}`),
+    ]));
+}
+export function parseSemanticCompactSelectors(value, label) {
+    const result = new Map();
+    for (const [index, item] of semanticArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, ["key", "members"]);
+        const key = semanticStableRef(row.key, `${itemLabel}.key`);
+        const members = semanticStableRefs(row.members, `${itemLabel}.members`);
+        if (result.has(key))
+            semanticFail(itemLabel, `duplicate key: ${key}`);
+        if (new Set(members).size !== members.length)
+            semanticFail(itemLabel, "members must be unique");
+        result.set(key, members);
+    }
+    return result;
+}
+export function parseSemanticCompactCatalogs(value, selectors, label) {
+    const row = semanticObject(value, label, [
+        ...SEMANTIC_COMPACT_CATALOG_COLLECTIONS,
+    ]);
+    return Object.fromEntries(SEMANTIC_COMPACT_CATALOG_COLLECTIONS.map((name) => [
+        name,
+        parseCompactTable(row[name], selectors, `${label}.${name}`),
+    ]));
+}
+export function parseSemanticCompactFactSets(value, selectors, label) {
+    const result = [];
+    const setKeys = new Set();
+    for (const [setIndex, item] of semanticArray(value, label).entries()) {
+        const setLabel = `${label}[${setIndex}]`;
+        const row = semanticObject(item, setLabel, [
+            "key",
+            "defaults",
+            "columns",
+            "rows",
+        ]);
+        const setKey = semanticStableRef(row.key, `${setLabel}.key`);
+        if (setKeys.has(setKey))
+            semanticFail(setLabel, `duplicate key: ${setKey}`);
+        setKeys.add(setKey);
+        const defaults = plainSemanticCompactObject(row.defaults, `${setLabel}.defaults`);
+        if (Object.hasOwn(defaults, "key"))
+            semanticFail(`${setLabel}.defaults`, "key cannot be defaulted");
+        const rows = parseCompactTable({ defaults, columns: row.columns, rows: row.rows }, selectors, setLabel);
+        for (const [rowIndex, factItem] of rows.entries()) {
+            const rowLabel = `${setLabel}.rows[${rowIndex}]`;
+            const factRow = plainSemanticCompactObject(factItem, rowLabel);
+            if (!Object.hasOwn(factRow, "fact_revision_digest"))
+                semanticFail(rowLabel, "missing fact_revision_digest");
+            const { fact_revision_digest: digestValue, ...fact } = factRow;
+            const revisionDigest = semanticSha256(digestValue, `${rowLabel}.fact_revision_digest`);
+            result.push({ fact, revision_digest: revisionDigest });
+        }
+    }
+    return result;
+}
+export function parseSemanticCompactProofTemplates(value, selectors, label) {
+    const result = new Map();
+    for (const [index, item] of semanticArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, ["key", "proof"]);
+        const key = semanticStableRef(row.key, `${itemLabel}.key`);
+        const proof = plainSemanticCompactObject(resolveSemanticCompactSelectors(row.proof, selectors, `${itemLabel}.proof`), `${itemLabel}.proof`);
+        if (Object.hasOwn(proof, "key") || Object.hasOwn(proof, "fact_ref"))
+            semanticFail(`${itemLabel}.proof`, "key and fact_ref belong to obligation rows");
+        if (result.has(key))
+            semanticFail(itemLabel, `duplicate key: ${key}`);
+        result.set(key, proof);
+    }
+    return result;
+}
+export function parseSemanticCompactObligations(value, templates, selectors, label) {
+    return parseCompactTable(value, selectors, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "obligation_key",
+            "obligation_revision_digest",
+            "fact_key",
+            "template_ref",
+            "overrides",
+        ]);
+        const obligationKey = semanticStableRef(row.obligation_key, `${itemLabel}.obligation_key`);
+        const factKey = semanticStableRef(row.fact_key, `${itemLabel}.fact_key`);
+        const templateRef = semanticStableRef(row.template_ref, `${itemLabel}.template_ref`);
+        const template = templates.get(templateRef);
+        if (!template)
+            semanticFail(`${itemLabel}.template_ref`, `unknown template: ${templateRef}`);
+        const overrides = plainSemanticCompactObject(resolveSemanticCompactSelectors(row.overrides, selectors, `${itemLabel}.overrides`), `${itemLabel}.overrides`);
+        if (Object.hasOwn(overrides, "key") || Object.hasOwn(overrides, "fact_ref"))
+            semanticFail(`${itemLabel}.overrides`, "key and fact_ref cannot be overridden");
+        const proof = {
+            ...template,
+            ...overrides,
+            key: obligationKey,
+            fact_ref: factKey,
+        };
+        const revisionDigest = semanticSha256(row.obligation_revision_digest, `${itemLabel}.obligation_revision_digest`);
+        return { proof, revision_digest: revisionDigest };
+    });
+}
+function parseCompactTable(value, selectors, label) {
+    const table = semanticObject(value, label, ["defaults", "columns", "rows"]);
+    const defaults = plainSemanticCompactObject(resolveSemanticCompactSelectors(table.defaults, selectors, `${label}.defaults`), `${label}.defaults`);
+    const columns = semanticArray(table.columns, `${label}.columns`).map((item, index) => {
+        const column = semanticString(item, `${label}.columns[${index}]`);
+        if (!/^[a-z][a-z0-9_]*$/u.test(column))
+            semanticFail(`${label}.columns[${index}]`, "invalid column name");
+        return column;
+    });
+    if (new Set(columns).size !== columns.length)
+        semanticFail(`${label}.columns`, "columns must be unique");
+    for (const column of columns)
+        if (Object.hasOwn(defaults, column))
+            semanticFail(`${label}.columns`, `column duplicates default field: ${column}`);
+    return semanticArray(table.rows, `${label}.rows`).map((item, index) => {
+        const rowLabel = `${label}.rows[${index}]`;
+        const values = semanticArray(item, rowLabel);
+        if (values.length !== columns.length)
+            semanticFail(rowLabel, `column count mismatch: ${values.length}:${columns.length}`);
+        return {
+            ...defaults,
+            ...Object.fromEntries(columns.map((column, columnIndex) => [
+                column,
+                resolveSemanticCompactSelectors(values[columnIndex], selectors, `${rowLabel}[${columnIndex}]`),
+            ])),
+        };
+    });
+}
+export function parseSemanticCompactExceptions(value, label) {
+    const seen = new Set();
+    for (const [index, item] of semanticArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "target_ref",
+            "rationale",
+        ]);
+        const key = semanticStableRef(row.key, `${itemLabel}.key`);
+        semanticStableRef(row.target_ref, `${itemLabel}.target_ref`);
+        if (typeof row.rationale !== "string" || !row.rationale.trim())
+            semanticFail(`${itemLabel}.rationale`, "must be a non-empty string");
+        if (seen.has(key))
+            semanticFail(itemLabel, `duplicate key: ${key}`);
+        seen.add(key);
+    }
+}

package/dist/lib/semantic-fact-compact-revision.d.ts

@@ -0,0 +1,11 @@
+export interface SemanticFactRevisionInput {
+    key: string;
+    kind: string;
+    source_ref: string;
+    sha256: string;
+}
+export declare function indexSemanticFactRevisionInputs(inputs: readonly Record<string, unknown>[]): Map<string, SemanticFactRevisionInput[]>;
+export declare function semanticFactRevisionDigest(fact: Record<string, unknown>, inputRevisionsByFact: ReadonlyMap<string, readonly SemanticFactRevisionInput[]>): string;
+export declare function semanticObligationRevisionDigest(obligation: Record<string, unknown>, factRevisionDigest: string): string;
+export declare function legacySemanticFactRevisionDigest(fact: Record<string, unknown>): string;
+export declare function legacySemanticObligationRevisionDigest(obligation: Record<string, unknown>): string;

package/dist/lib/semantic-fact-compact-revision.js

@@ -0,0 +1,64 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+function normalizeLocatedValues(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeLocatedValues);
+    if (!value || typeof value !== "object")
+        return value;
+    const row = value;
+    if (Object.hasOwn(row, "representation") &&
+        Object.hasOwn(row, "locator") &&
+        Object.hasOwn(row, "sha256")) {
+        const { locator: _locator, ...rest } = row;
+        return Object.fromEntries(Object.entries(rest).map(([key, item]) => [
+            key,
+            normalizeLocatedValues(item),
+        ]));
+    }
+    return Object.fromEntries(Object.entries(row).map(([key, item]) => [
+        key,
+        normalizeLocatedValues(item),
+    ]));
+}
+export function indexSemanticFactRevisionInputs(inputs) {
+    const result = new Map();
+    for (const input of inputs) {
+        const revision = {
+            key: String(input.key),
+            kind: String(input.kind),
+            source_ref: String(input.source_ref),
+            sha256: String(input.sha256),
+        };
+        const factRefs = Array.isArray(input.fact_refs) ? input.fact_refs : [];
+        for (const factRef of factRefs) {
+            const key = String(factRef);
+            const rows = result.get(key) ?? [];
+            rows.push(revision);
+            result.set(key, rows);
+        }
+    }
+    for (const rows of result.values())
+        rows.sort((left, right) => left.key.localeCompare(right.key));
+    return result;
+}
+export function semanticFactRevisionDigest(fact, inputRevisionsByFact) {
+    const { key: _key, ...meaning } = fact;
+    return sha256Hex(canonicalValueJson({
+        meaning: normalizeLocatedValues(meaning),
+        input_revisions: inputRevisionsByFact.get(String(fact.key)) ?? [],
+    }));
+}
+export function semanticObligationRevisionDigest(obligation, factRevisionDigest) {
+    const { key: _key, ...meaning } = obligation;
+    return sha256Hex(canonicalValueJson({
+        meaning: normalizeLocatedValues(meaning),
+        fact_revision_digest: factRevisionDigest,
+    }));
+}
+export function legacySemanticFactRevisionDigest(fact) {
+    const { key: _key, ...meaning } = fact;
+    return sha256Hex(canonicalValueJson(normalizeLocatedValues(meaning)));
+}
+export function legacySemanticObligationRevisionDigest(obligation) {
+    const { key: _key, ...meaning } = obligation;
+    return sha256Hex(canonicalValueJson(normalizeLocatedValues(meaning)));
+}

package/dist/lib/semantic-fact-compact-support.d.ts

@@ -0,0 +1,23 @@
+import { type SemanticFactManifestCollectionName, type SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { CompactSharedStructureTarget } from "./compact-shared-structures.js";
+export { SEMANTIC_COMPACT_CAPACITY_FIELDS, validateSemanticCompactCapacity, validateSemanticCompactDeclaredMaximum, type SemanticCompactCapacityCounts, } from "./semantic-fact-compact-capacity.js";
+export { indexSemanticFactRevisionInputs, legacySemanticFactRevisionDigest, legacySemanticObligationRevisionDigest, semanticFactRevisionDigest, semanticObligationRevisionDigest, type SemanticFactRevisionInput, } from "./semantic-fact-compact-revision.js";
+export declare const SEMANTIC_COMPACT_CATALOG_COLLECTIONS: readonly ["inputs", "family_dispositions", "subjects", "relations", "populations", "axis_dispositions", "condition_rules", "conditions", "condition_exclusions", "property_dispositions", "fact_cells", "oracles", "environments", "blockers"];
+export type SemanticCompactCatalogs = Record<(typeof SEMANTIC_COMPACT_CATALOG_COLLECTIONS)[number], unknown[]>;
+export declare function resolveSemanticCompactSelectors(value: unknown, selectors: Map<string, string[]>, label: string): unknown;
+export declare function plainSemanticCompactObject(value: unknown, label: string): Record<string, unknown>;
+export declare function assertUniqueSemanticCompactKeys(rows: unknown[], label: string): void;
+export declare function emptySemanticCompactCollectionRows(catalogs: Record<(typeof SEMANTIC_COMPACT_CATALOG_COLLECTIONS)[number], unknown[]>, facts: Array<{
+    fact: Record<string, unknown>;
+}>, obligations: Array<{
+    proof: Record<string, unknown>;
+}>): Record<SemanticFactManifestCollectionName, Array<{
+    key: string;
+}>>;
+export declare function semanticCompactCollectionRows(manifest: SemanticFactManifestV1): Record<SemanticFactManifestCollectionName, Array<{
+    key: string;
+}>>;
+export declare function semanticCompactGeneration(rows: Record<SemanticFactManifestCollectionName, Array<{
+    key: string;
+}>>): SemanticFactManifestV1["generation"];
+export declare function semanticCompactSharedStructureTargets(root: Record<string, unknown>): CompactSharedStructureTarget[];

package/dist/lib/semantic-fact-compact-support.js

@@ -0,0 +1,159 @@
+import { SEMANTIC_FACT_MANIFEST_COLLECTIONS, } from "./semantic-fact-types.js";
+import { semanticFactCollectionIdentity } from "./semantic-fact-policy.js";
+import { semanticFail, semanticStableRef, } from "./semantic-fact-shape-primitives.js";
+export { SEMANTIC_COMPACT_CAPACITY_FIELDS, validateSemanticCompactCapacity, validateSemanticCompactDeclaredMaximum, } from "./semantic-fact-compact-capacity.js";
+export { indexSemanticFactRevisionInputs, legacySemanticFactRevisionDigest, legacySemanticObligationRevisionDigest, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-revision.js";
+export const SEMANTIC_COMPACT_CATALOG_COLLECTIONS = [
+    "inputs",
+    "family_dispositions",
+    "subjects",
+    "relations",
+    "populations",
+    "axis_dispositions",
+    "condition_rules",
+    "conditions",
+    "condition_exclusions",
+    "property_dispositions",
+    "fact_cells",
+    "oracles",
+    "environments",
+    "blockers",
+];
+export function resolveSemanticCompactSelectors(value, selectors, label) {
+    if (Array.isArray(value))
+        return value.map((item, index) => resolveSemanticCompactSelectors(item, selectors, `${label}[${index}]`));
+    if (!value || typeof value !== "object")
+        return value;
+    const row = value;
+    if (Object.keys(row).length === 1 && Object.hasOwn(row, "selector_ref")) {
+        const selectorRef = semanticStableRef(row.selector_ref, `${label}.selector_ref`);
+        const members = selectors.get(selectorRef);
+        if (!members)
+            semanticFail(`${label}.selector_ref`, `unknown selector: ${selectorRef}`);
+        return [...members];
+    }
+    if (Object.hasOwn(row, "selector_ref"))
+        semanticFail(label, "selector_ref must be the only key in its object");
+    return Object.fromEntries(Object.entries(row).map(([key, item]) => [
+        key,
+        resolveSemanticCompactSelectors(item, selectors, `${label}.${key}`),
+    ]));
+}
+export function plainSemanticCompactObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        semanticFail(label, "must be an object");
+    return value;
+}
+export function assertUniqueSemanticCompactKeys(rows, label) {
+    const seen = new Set();
+    for (const [index, keyValue] of rows.entries()) {
+        const key = semanticStableRef(keyValue, `${label}[${index}].key`);
+        if (seen.has(key))
+            semanticFail(label, `duplicate key: ${key}`);
+        seen.add(key);
+    }
+}
+export function emptySemanticCompactCollectionRows(catalogs, facts, obligations) {
+    return {
+        ...Object.fromEntries(SEMANTIC_COMPACT_CATALOG_COLLECTIONS.map((name) => [
+            name,
+            catalogs[name],
+        ])),
+        inspector_census: [],
+        facts: facts.map((item) => item.fact),
+        proof_obligations: obligations.map((item) => item.proof),
+    };
+}
+export function semanticCompactCollectionRows(manifest) {
+    return {
+        inputs: manifest.inputs,
+        inspector_census: manifest.inspector.census,
+        family_dispositions: manifest.family_dispositions,
+        subjects: manifest.subjects,
+        relations: manifest.relations,
+        populations: manifest.populations,
+        axis_dispositions: manifest.axis_dispositions,
+        condition_rules: manifest.condition_rules,
+        conditions: manifest.conditions,
+        condition_exclusions: manifest.condition_exclusions,
+        property_dispositions: manifest.property_dispositions,
+        fact_cells: manifest.fact_cells,
+        facts: manifest.facts,
+        proof_obligations: manifest.proof_obligations,
+        oracles: manifest.oracles,
+        environments: manifest.environments,
+        blockers: manifest.blockers,
+    };
+}
+export function semanticCompactGeneration(rows) {
+    return {
+        strategy: "complete_explicit",
+        sampling: "forbidden",
+        truncation: "forbidden",
+        chunk_count: 1,
+        chunk_indexes: [0],
+        collections: SEMANTIC_FACT_MANIFEST_COLLECTIONS.map((name) => ({
+            name,
+            expected_count: rows[name].length,
+            identity_sha256: semanticFactCollectionIdentity(rows[name]),
+        })),
+    };
+}
+export function semanticCompactSharedStructureTargets(root) {
+    const targets = [];
+    addObjectFieldTargets(targets, root.scope, "source.scope");
+    addObjectFieldTargets(targets, root.inspector, "source.inspector");
+    const catalogs = plainRecord(root.catalogs);
+    for (const name of SEMANTIC_COMPACT_CATALOG_COLLECTIONS)
+        addCompactTableTargets(targets, catalogs?.[name], `source.catalog.${name}`);
+    if (Array.isArray(root.fact_sets))
+        for (const factSet of root.fact_sets)
+            addCompactTableTargets(targets, factSet, "source.fact");
+    if (Array.isArray(root.proof_templates))
+        for (const template of root.proof_templates) {
+            const row = plainRecord(template);
+            if (row && Object.hasOwn(row, "proof"))
+                addTarget(targets, row, "proof", "source.proof.policy");
+        }
+    addCompactTableTargets(targets, root.obligations, "source.obligation");
+    return targets;
+}
+function addCompactTableTargets(targets, value, boundary) {
+    const table = plainRecord(value);
+    if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows))
+        return;
+    const columns = table.columns.map(String);
+    addObjectFieldTargets(targets, table.defaults, `${boundary}.default`);
+    for (const rowValue of table.rows) {
+        if (!Array.isArray(rowValue) || rowValue.length !== columns.length)
+            continue;
+        for (const [index, column] of columns.entries())
+            if (isComposite(rowValue[index]))
+                addTarget(targets, rowValue, index, `${boundary}.${column}`);
+    }
+}
+function addObjectFieldTargets(targets, value, boundary) {
+    const row = plainRecord(value);
+    if (!row)
+        return;
+    for (const key of Object.keys(row))
+        if (isComposite(row[key]))
+            addTarget(targets, row, key, `${boundary}.${key}`);
+}
+function addTarget(targets, parent, key, boundary) {
+    targets.push({
+        boundary,
+        read: () => parent[key],
+        write: (value) => {
+            parent[key] = value;
+        },
+    });
+}
+function plainRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function isComposite(value) {
+    return Boolean(value && typeof value === "object");
+}

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

@@ -1,2 +1,3 @@
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
 export declare function validateSemanticFactInspectorCensus(manifest: SemanticFactManifestV1): void;
+export declare function buildSemanticFactInspectorCensus(manifest: SemanticFactManifestV1): SemanticFactManifestV1["inspector"]["census"];

package/dist/lib/semantic-fact-policy-census.js

@@ -32,6 +32,49 @@ export function validateSemanticFactInspectorCensus(manifest) {
     }
     assertSameSemanticFactSet([...actual], [...expected.keys()], "inspector_census_universe");
 }
+export function buildSemanticFactInspectorCensus(manifest) {
+    const factsFor = (predicate) => manifest.facts.filter(predicate).map((item) => item.key);
+    return [...expectedCensusRows(manifest, factsFor).entries()].map(([identity, expectation]) => {
+        const separator = identity.indexOf(":");
+        const kind = identity.slice(0, separator);
+        const key = identity.slice(separator + 1);
+        const basisRefs = censusBasisRefs(kind, expectation.row, expectation.fact_refs, manifest);
+        return {
+            key,
+            kind,
+            locator: {
+                material_ref: manifest.key,
+                kind: "manifest_pointer",
+                value: expectation.pointer,
+            },
+            identity_sha256: sha256Hex(canonicalValueJson(expectation.row)),
+            disposition: expectation.fact_refs.length
+                ? "material_with_facts"
+                : "supporting_only",
+            fact_refs: expectation.fact_refs,
+            basis_refs: basisRefs,
+            rationale: expectation.fact_refs.length
+                ? "This census identity contributes to an exact semantic Fact."
+                : "This identity is explicitly inventoried as supporting or inapplicable.",
+        };
+    });
+}
+function censusBasisRefs(kind, row, factRefs, manifest) {
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+        const record = row;
+        for (const field of ["basis_refs", "source_item_refs"])
+            if (Array.isArray(record[field]) &&
+                record[field].every((item) => typeof item === "string") &&
+                record[field].length)
+                return [...record[field]];
+    }
+    if (kind === "proof_obligation" && factRefs.length) {
+        const fact = manifest.facts.find((item) => item.key === factRefs[0]);
+        if (fact?.source_item_refs.length)
+            return [...fact.source_item_refs];
+    }
+    return [manifest.scope.source_item_refs[0]];
+}
 function expectedCensusRows(manifest, factsFor) {
     const result = new Map();
     const add = (kind, key, pointer, row, factRefs) => result.set(`${kind}:${key}`, {

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

@@ -31,7 +31,7 @@ export declare function parseSemanticFactProofObligations(value: unknown, label:
     method: string;
     authority: "external_confirmation" | "machine";
     proof_surface: "api_contract" | "data_state" | "implementation_structure" | "population_coverage" | "runtime_behavior" | "security_boundary" | "ui_browser";
-    evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
     comparison: {
         comparator: string;
         mode: "exact" | "tolerance";

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

@@ -5,7 +5,7 @@ export declare function parseSemanticFactPropertyDispositions(value: unknown, la
     standard: boolean;
     value_kind: "boolean" | "custom" | "decision_table" | "digest" | "duration" | "enum" | "formula" | "number" | "object" | "ordered_list" | "range" | "rate" | "ratio" | "relation" | "schema" | "set" | "string" | "timestamp" | "trace";
     required_methods: string[];
-    required_evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    required_evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
     applicable_unit_refs: string[];
     not_applicable_unit_refs: string[];
     decision_required_unit_refs: string[];

package/dist/lib/semantic-fact-source-parser.d.ts

@@ -1,9 +1,14 @@
+import { type SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
 export interface ParsedSemanticFactManifestV1 {
     source_path: string;
     line: number;
     manifest: SemanticFactManifestV1;
     sha256: string;
+    carrier: "expanded_v1" | "compact_v1";
+    fact_revisions: SemanticFactRevisionIdentityV1[];
+    obligation_revisions: SemanticFactRevisionIdentityV1[];
 }
 export declare function parseSemanticFactManifestBlocks(sourcePath: string, content: string): ParsedSemanticFactManifestV1[];
+export declare function parseSemanticFactManifestBlocksForMigration(sourcePath: string, content: string): ParsedSemanticFactManifestV1[];
 export declare function loadSemanticFactManifest(repository: string, sourcePaths: string[]): Promise<ParsedSemanticFactManifestV1>;

package/dist/lib/semantic-fact-source-parser.js

@@ -1,37 +1,78 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { indexSemanticFactRevisionInputs, parseSemanticFactCompactCarrierForMigration, parseSemanticFactCompactCarrierShape, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-carrier.js";
 import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
 import { canonicalValueJson, parseStrictYaml, sha256Hex, } from "./strict-codec.js";
-const START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
+const START = /^\s*```yaml[ \t]+(semantic-fact-manifest-v1|semantic-fact-compact-carrier-v1)[ \t]*$/u;
 const END = /^\s*```[ \t]*$/u;
 export function parseSemanticFactManifestBlocks(sourcePath, content) {
+    return parseSemanticFactManifestBlocksWithMode(sourcePath, content, false);
+}
+export function parseSemanticFactManifestBlocksForMigration(sourcePath, content) {
+    return parseSemanticFactManifestBlocksWithMode(sourcePath, content, true);
+}
+function parseSemanticFactManifestBlocksWithMode(sourcePath, content, allowLegacyRevisionIdentity) {
     const rows = [];
     const lines = content.replace(/\r\n?/gu, "\n").split("\n");
     let open = null;
     for (const [index, line] of lines.entries()) {
         if (!open) {
-            if (START.test(line))
-                open = { line: index + 1, lines: [] };
+            const match = START.exec(line);
+            if (match)
+                open = { line: index + 1, lines: [], kind: match[1] };
             continue;
         }
         if (!END.test(line)) {
             open.lines.push(line);
             continue;
         }
-        const manifest = parseSemanticFactManifestShape(parseStrictYaml(open.lines.join("\n")));
+        const decoded = parseStrictYaml(open.lines.join("\n"));
+        const compact = open.kind === "semantic-fact-compact-carrier-v1";
+        const materialized = compact
+            ? allowLegacyRevisionIdentity
+                ? parseSemanticFactCompactCarrierForMigration(decoded)
+                : parseSemanticFactCompactCarrierShape(decoded)
+            : null;
+        const manifest = materialized
+            ? materialized.manifest
+            : parseSemanticFactManifestShape(decoded);
+        const expandedRevisions = materialized
+            ? null
+            : semanticFactRevisionIdentities(manifest);
         rows.push({
             source_path: sourcePath,
             line: open.line,
             manifest,
-            sha256: sha256Hex(canonicalValueJson(manifest)),
+            sha256: sha256Hex(canonicalValueJson(compact ? decoded : manifest)),
+            carrier: compact ? "compact_v1" : "expanded_v1",
+            fact_revisions: materialized?.fact_revisions ?? expandedRevisions.facts,
+            obligation_revisions: materialized?.obligation_revisions ?? expandedRevisions.obligations,
         });
         open = null;
     }
     if (open)
-        throw new Error(`source_formal_block_unclosed:${sourcePath}:semantic-fact-manifest-v1:${open.line}`);
+        throw new Error(`source_formal_block_unclosed:${sourcePath}:${open.kind}:${open.line}`);
     return rows;
 }
+function semanticFactRevisionIdentities(manifest) {
+    const inputRevisionsByFact = indexSemanticFactRevisionInputs(manifest.inputs);
+    const facts = manifest.facts.map((fact) => ({
+        key: fact.key,
+        revision_digest: semanticFactRevisionDigest(fact, inputRevisionsByFact),
+    }));
+    const factRevisionByKey = new Map(facts.map((item) => [item.key, item.revision_digest]));
+    const obligations = manifest.proof_obligations.map((proof) => {
+        const factRevision = factRevisionByKey.get(proof.fact_ref);
+        if (!factRevision)
+            throw new Error(`semantic_fact_revision_unknown_fact:${proof.key}:${proof.fact_ref}`);
+        return {
+            key: proof.key,
+            revision_digest: semanticObligationRevisionDigest(proof, factRevision),
+        };
+    });
+    return { facts, obligations };
+}
 export async function loadSemanticFactManifest(repository, sourcePaths) {
     const rows = [];
     for (const [index, sourcePath] of sourcePaths.entries()) {