project-tiny-context-harness 0.8.10 → 0.8.12

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

@@ -0,0 +1,40 @@
+import { semanticFail } from "./semantic-fact-shape-primitives.js";
+export const SEMANTIC_COMPACT_CAPACITY_FIELDS = [
+    "inputs",
+    "catalog_rows",
+    "selector_members",
+    "structure_families",
+    "structure_references",
+    "structure_arguments",
+    "facts",
+    "obligations",
+    "census",
+    "canonical_bytes",
+];
+const PACKAGE_MAXIMUM = {
+    inputs: 100_000,
+    catalog_rows: 2_000_000,
+    selector_members: 5_000_000,
+    structure_families: 1_000_000,
+    structure_references: 10_000_000,
+    structure_arguments: 50_000_000,
+    facts: 1_000_000,
+    obligations: 2_000_000,
+    census: 10_000_000,
+    canonical_bytes: 256 * 1024 * 1024,
+};
+export function validateSemanticCompactCapacity(capacity, measured, label) {
+    for (const field of SEMANTIC_COMPACT_CAPACITY_FIELDS) {
+        if (capacity.maximum[field] > PACKAGE_MAXIMUM[field])
+            semanticFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+        if (capacity.measured[field] !== measured[field])
+            semanticFail(`${label}.capacity.measured.${field}`, `measured mismatch: ${capacity.measured[field]}:${measured[field]}`);
+        if (measured[field] > capacity.maximum[field])
+            semanticFail(`${label}.capacity.maximum.${field}`, `capacity exceeded: ${measured[field]}:${capacity.maximum[field]}`);
+    }
+}
+export function validateSemanticCompactDeclaredMaximum(maximum, label) {
+    for (const field of SEMANTIC_COMPACT_CAPACITY_FIELDS)
+        if (maximum[field] > PACKAGE_MAXIMUM[field])
+            semanticFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+}

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

@@ -0,0 +1,16 @@
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import { type SemanticCompactCapacityCounts } from "./semantic-fact-compact-support.js";
+export { indexSemanticFactRevisionInputs, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-support.js";
+export declare const SEMANTIC_FACT_COMPACT_CARRIER_VERSION: "semantic-fact-compact-carrier-v1";
+export interface SemanticFactRevisionIdentityV1 {
+    key: string;
+    revision_digest: string;
+}
+export interface MaterializedSemanticFactCompactCarrierV1 {
+    manifest: SemanticFactManifestV1;
+    fact_revisions: SemanticFactRevisionIdentityV1[];
+    obligation_revisions: SemanticFactRevisionIdentityV1[];
+    measured: SemanticCompactCapacityCounts;
+}
+export declare function parseSemanticFactCompactCarrierShape(value: unknown): MaterializedSemanticFactCompactCarrierV1;
+export declare function parseSemanticFactCompactCarrierForMigration(value: unknown): MaterializedSemanticFactCompactCarrierV1;

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

@@ -0,0 +1,146 @@
+import { Buffer } from "node:buffer";
+import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
+import { buildSemanticFactInspectorCensus } from "./semantic-fact-policy-census.js";
+import { semanticFail, semanticLiteral, semanticObject, semanticStableRef, } from "./semantic-fact-shape-primitives.js";
+import { canonicalValueJson } from "./strict-codec.js";
+import { materializeCanonicalCompactSharedStructures } from "./compact-shared-structure-validation.js";
+import { parseSemanticCompactCapacity, parseSemanticCompactCatalogs, parseSemanticCompactExceptions, parseSemanticCompactFactSets, parseSemanticCompactObligations, parseSemanticCompactProofTemplates, parseSemanticCompactSelectors, } from "./semantic-fact-compact-parser.js";
+import { SEMANTIC_COMPACT_CATALOG_COLLECTIONS, assertUniqueSemanticCompactKeys, emptySemanticCompactCollectionRows, indexSemanticFactRevisionInputs, legacySemanticFactRevisionDigest, legacySemanticObligationRevisionDigest, semanticFactRevisionDigest, semanticObligationRevisionDigest, semanticCompactCollectionRows, semanticCompactGeneration, semanticCompactSharedStructureTargets, resolveSemanticCompactSelectors, validateSemanticCompactCapacity, validateSemanticCompactDeclaredMaximum, } from "./semantic-fact-compact-support.js";
+export { indexSemanticFactRevisionInputs, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-support.js";
+export const SEMANTIC_FACT_COMPACT_CARRIER_VERSION = "semantic-fact-compact-carrier-v1";
+export function parseSemanticFactCompactCarrierShape(value) {
+    return parseSemanticFactCompactCarrier(value, false);
+}
+export function parseSemanticFactCompactCarrierForMigration(value) {
+    return parseSemanticFactCompactCarrier(value, true);
+}
+function parseSemanticFactCompactCarrier(value, allowLegacyRevisionIdentity) {
+    const label = "semantic_fact_compact_carrier";
+    const working = structuredClone(value);
+    const hadSharedStructures = Boolean(working &&
+        typeof working === "object" &&
+        Object.hasOwn(working, "shared_structures"));
+    if (allowLegacyRevisionIdentity && !hadSharedStructures) {
+        working.shared_structures = [];
+        addLegacyStructureCapacityFields(working.capacity);
+    }
+    const root = semanticObject(working, label, [
+        "schema_version",
+        "key",
+        "capacity",
+        "scope",
+        "inspector",
+        "selectors",
+        "shared_structures",
+        "catalogs",
+        "fact_sets",
+        "proof_templates",
+        "obligations",
+        "exceptions",
+    ]);
+    semanticLiteral(root.schema_version, [SEMANTIC_FACT_COMPACT_CARRIER_VERSION], `${label}.schema_version`);
+    const key = semanticStableRef(root.key, `${label}.key`);
+    const capacity = parseSemanticCompactCapacity(root.capacity, `${label}.capacity`);
+    validateSemanticCompactDeclaredMaximum(capacity.maximum, label);
+    const structureStatistics = hadSharedStructures
+        ? materializeCanonicalCompactSharedStructures(semanticCompactSharedStructureTargets(root), root.shared_structures, label)
+        : {
+            emitted_family_count: 0,
+            reference_count: 0,
+            argument_count: 0,
+        };
+    const selectors = parseSemanticCompactSelectors(root.selectors, `${label}.selectors`);
+    const catalogs = parseSemanticCompactCatalogs(root.catalogs, selectors, `${label}.catalogs`);
+    const factRows = parseSemanticCompactFactSets(root.fact_sets, selectors, `${label}.fact_sets`);
+    const proofTemplates = parseSemanticCompactProofTemplates(root.proof_templates, selectors, `${label}.proof_templates`);
+    const obligationRows = parseSemanticCompactObligations(root.obligations, proofTemplates, selectors, `${label}.obligations`);
+    parseSemanticCompactExceptions(root.exceptions, `${label}.exceptions`);
+    assertUniqueSemanticCompactKeys(factRows.map((item) => item.fact.key), `${label}.facts`);
+    assertUniqueSemanticCompactKeys(obligationRows.map((item) => item.proof.key), `${label}.obligations`);
+    const factKeys = new Set(factRows.map((item) => item.fact.key));
+    for (const row of obligationRows)
+        if (!factKeys.has(row.proof.fact_ref))
+            semanticFail(`${label}.obligations`, `unknown fact_key: ${row.proof.fact_ref}`);
+    const preliminary = parseSemanticFactManifestShape({
+        schema_version: "semantic-fact-manifest-v1",
+        key,
+        scope: resolveSemanticCompactSelectors(root.scope, selectors, `${label}.scope`),
+        inspector: {
+            ...resolveSemanticCompactSelectors(root.inspector, selectors, `${label}.inspector`),
+            census: [],
+        },
+        generation: semanticCompactGeneration(emptySemanticCompactCollectionRows(catalogs, factRows, obligationRows)),
+        ...catalogs,
+        facts: factRows.map((item) => item.fact),
+        proof_obligations: obligationRows.map((item) => item.proof),
+    });
+    preliminary.inspector.census = buildSemanticFactInspectorCensus(preliminary);
+    preliminary.generation = semanticCompactGeneration(semanticCompactCollectionRows(preliminary));
+    const manifest = parseSemanticFactManifestShape(preliminary);
+    const inputRevisionsByFact = indexSemanticFactRevisionInputs(manifest.inputs);
+    const currentFactRevisions = new Map(manifest.facts.map((fact) => [
+        fact.key,
+        semanticFactRevisionDigest(fact, inputRevisionsByFact),
+    ]));
+    for (const row of factRows) {
+        const key = semanticStableRef(row.fact.key, `${label}.fact_revision.key`);
+        const current = currentFactRevisions.get(key);
+        const legacy = legacySemanticFactRevisionDigest(row.fact);
+        if (row.revision_digest !== current &&
+            (!allowLegacyRevisionIdentity || row.revision_digest !== legacy))
+            semanticFail(`${label}.fact_revision.${key}`, `revision digest mismatch: ${row.revision_digest}:${current}`);
+    }
+    const currentObligationRevisions = new Map();
+    for (const row of obligationRows) {
+        const key = semanticStableRef(row.proof.key, `${label}.obligation_revision.key`);
+        const factRef = semanticStableRef(row.proof.fact_ref, `${label}.obligation_revision.fact_ref`);
+        const factRevision = currentFactRevisions.get(factRef);
+        if (!factRevision)
+            semanticFail(`${label}.obligation_revision.${key}`, `unknown fact revision: ${factRef}`);
+        const current = semanticObligationRevisionDigest(row.proof, factRevision);
+        const legacy = legacySemanticObligationRevisionDigest(row.proof);
+        if (row.revision_digest !== current &&
+            (!allowLegacyRevisionIdentity || row.revision_digest !== legacy))
+            semanticFail(`${label}.obligation_revision.${key}`, `revision digest mismatch: ${row.revision_digest}:${current}`);
+        currentObligationRevisions.set(key, current);
+    }
+    const measured = {
+        inputs: manifest.inputs.length,
+        catalog_rows: SEMANTIC_COMPACT_CATALOG_COLLECTIONS.reduce((sum, name) => sum + manifest[name].length, 0),
+        selector_members: [...selectors.values()].reduce((sum, members) => sum + members.length, 0),
+        structure_families: structureStatistics.emitted_family_count,
+        structure_references: structureStatistics.reference_count,
+        structure_arguments: structureStatistics.argument_count,
+        facts: manifest.facts.length,
+        obligations: manifest.proof_obligations.length,
+        census: manifest.inspector.census.length,
+        canonical_bytes: Buffer.byteLength(canonicalValueJson(manifest), "utf8"),
+    };
+    validateSemanticCompactCapacity(capacity, measured, label);
+    return {
+        manifest,
+        fact_revisions: factRows.map((item) => ({
+            key: semanticStableRef(item.fact.key, `${label}.fact_revision.key`),
+            revision_digest: currentFactRevisions.get(String(item.fact.key)),
+        })),
+        obligation_revisions: obligationRows.map((item) => ({
+            key: semanticStableRef(item.proof.key, `${label}.obligation_revision.key`),
+            revision_digest: currentObligationRevisions.get(String(item.proof.key)),
+        })),
+        measured,
+    };
+}
+function addLegacyStructureCapacityFields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return;
+    const capacity = value;
+    for (const field of ["measured", "maximum"]) {
+        const counts = capacity[field];
+        if (!counts || typeof counts !== "object" || Array.isArray(counts))
+            continue;
+        const row = counts;
+        row.structure_families = 0;
+        row.structure_references = 0;
+        row.structure_arguments = 0;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type SemanticCompactCapacityCounts, type SemanticCompactCatalogs } from "./semantic-fact-compact-support.js";
+export declare function parseSemanticCompactCapacity(value: unknown, label: string): {
+    measured: SemanticCompactCapacityCounts;
+    maximum: SemanticCompactCapacityCounts;
+};
+export declare function parseSemanticCompactSelectors(value: unknown, label: string): Map<string, string[]>;
+export declare function parseSemanticCompactCatalogs(value: unknown, selectors: Map<string, string[]>, label: string): SemanticCompactCatalogs;
+export declare function parseSemanticCompactFactSets(value: unknown, selectors: Map<string, string[]>, label: string): Array<{
+    fact: Record<string, unknown>;
+    revision_digest: string;
+}>;
+export declare function parseSemanticCompactProofTemplates(value: unknown, selectors: Map<string, string[]>, label: string): Map<string, Record<string, unknown>>;
+export declare function parseSemanticCompactObligations(value: unknown, templates: Map<string, Record<string, unknown>>, selectors: Map<string, string[]>, label: string): Array<{
+    proof: Record<string, unknown>;
+    revision_digest: string;
+}>;
+export declare function parseSemanticCompactExceptions(value: unknown, label: string): void;

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"];