project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/repository-path-safety.js

@@ -0,0 +1,126 @@
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import path from "node:path";
+export function resolveInsideRepository(rootInput, relativeInput, label) {
+    if (!relativeInput || path.isAbsolute(relativeInput))
+        throw new Error(`unsafe_path:${label}:${relativeInput}`);
+    const normalized = relativeInput.replace(/\\/gu, "/");
+    if (normalized.split("/").some((segment) => segment === "..") ||
+        normalized.startsWith("//") ||
+        /^[A-Za-z]:/u.test(normalized))
+        throw new Error(`unsafe_path:${label}:${relativeInput}`);
+    const root = path.resolve(rootInput);
+    const resolved = path.resolve(root, ...normalized.split("/"));
+    if (!inside(root, resolved))
+        throw new Error(`unsafe_path:${label}:${relativeInput}`);
+    return resolved;
+}
+export async function assertProtectedRepositoryFile(repositoryInput, fileInput, label) {
+    const repositoryPath = path.resolve(repositoryInput);
+    const repository = await realpath(repositoryPath);
+    const candidate = path.resolve(fileInput);
+    assertInside(repositoryPath, candidate, label, fileInput);
+    await assertExistingParents(repositoryPath, repository, candidate, label);
+    const info = await lstatOrNull(candidate);
+    if (!info)
+        throw new Error(`protected_input_not_found:${label}:${display(fileInput)}`);
+    assertRegularNoFollow(info, label, fileInput);
+    const resolved = await realpath(candidate);
+    assertInside(repository, resolved, label, fileInput);
+    return resolved;
+}
+export async function assertSafeRepositoryFilePath(repositoryInput, relativeInput, label, options = {}) {
+    const repositoryPath = path.resolve(repositoryInput);
+    const repository = await realpath(repositoryPath);
+    const absolute = resolveInsideRepository(repositoryPath, relativeInput, label);
+    await assertExistingParents(repositoryPath, repository, absolute, label);
+    const status = await lstatOrNull(absolute);
+    if (!status && !options.destinationMayBeAbsent)
+        throw new Error(`protected_input_not_found:${label}:${display(relativeInput)}`);
+    if (status) {
+        assertRegularNoFollow(status, label, relativeInput);
+        assertInside(repository, await realpath(absolute), label, relativeInput);
+    }
+    return {
+        repository,
+        absolute,
+        relative: repositoryRelative(repositoryPath, absolute, label),
+        status,
+    };
+}
+export async function ensureSafeRepositoryDirectory(repositoryInput, relativeInput, label) {
+    const repositoryPath = path.resolve(repositoryInput);
+    const repository = await realpath(repositoryPath);
+    const absolute = resolveInsideRepository(repositoryPath, relativeInput, label);
+    const relative = repositoryRelative(repositoryPath, absolute, label);
+    let cursor = repositoryPath;
+    for (const segment of relative.split(path.sep)) {
+        cursor = path.join(cursor, segment);
+        let status = await lstatOrNull(cursor);
+        if (!status) {
+            await mkdir(cursor).catch((error) => {
+                if (error.code !== "EEXIST")
+                    throw error;
+            });
+            status = await lstatOrNull(cursor);
+        }
+        if (!status || status.isSymbolicLink() || !status.isDirectory())
+            throw new Error(`unsafe_repository_directory:${label}:${display(relativeInput)}`);
+        assertInside(repository, await realpath(cursor), label, relativeInput);
+    }
+    return { repository, absolute, relative: relative.replace(/\\/gu, "/") };
+}
+async function assertExistingParents(lexicalRepository, canonicalRepository, candidate, label) {
+    const relative = repositoryRelative(lexicalRepository, path.dirname(candidate), label);
+    if (!relative)
+        return;
+    let cursor = lexicalRepository;
+    for (const segment of relative.split(path.sep)) {
+        cursor = path.join(cursor, segment);
+        const status = await lstatOrNull(cursor);
+        if (!status)
+            throw new Error(`protected_input_parent_not_found:${label}:${display(cursor)}`);
+        if (status.isSymbolicLink())
+            throw new Error(`protected_input_parent_symlink_not_allowed:${label}:${display(cursor)}`);
+        if (!status.isDirectory())
+            throw new Error(`protected_input_parent_not_directory:${label}:${display(cursor)}`);
+        assertInside(canonicalRepository, await realpath(cursor), label, cursor);
+    }
+}
+function assertRegularNoFollow(info, label, original) {
+    if (info.isSymbolicLink())
+        throw new Error(`protected_input_symlink_not_allowed:${label}:${display(original)}`);
+    if (!info.isFile())
+        throw new Error(`protected_input_not_regular_file:${label}:${display(original)}`);
+    if (typeof info.nlink === "number" && info.nlink > 1)
+        throw new Error(`protected_input_hardlink_not_allowed:${label}:${display(original)}`);
+}
+function repositoryRelative(repository, candidate, label) {
+    const relative = path.relative(repository, candidate);
+    if (!inside(repository, candidate))
+        throw new Error(`protected_input_realpath_outside_repository:${label}:${display(candidate)}`);
+    return relative;
+}
+function assertInside(repository, candidate, label, original) {
+    if (!inside(repository, candidate))
+        throw new Error(`protected_input_realpath_outside_repository:${label}:${display(original)}`);
+}
+function inside(repository, candidate) {
+    const relative = path.relative(repository, candidate);
+    return (relative === "" ||
+        (relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)));
+}
+async function lstatOrNull(target) {
+    try {
+        return await lstat(target);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function display(file) {
+    return file.replace(/\\/gu, "/");
+}

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

@@ -0,0 +1,2 @@
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function createSemanticFactCompactCarrier(manifestInput: SemanticFactManifestV1): Record<string, unknown>;

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

@@ -0,0 +1,160 @@
+import { Buffer } from "node:buffer";
+import { indexSemanticFactRevisionInputs, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-carrier.js";
+import { buildSemanticFactInspectorCensus } from "./semantic-fact-policy-census.js";
+import { semanticFactCollectionIdentity } from "./semantic-fact-policy.js";
+import { canonicalValueJson } from "./strict-codec.js";
+import { applyCompactAuthoringSelectors, compactAuthoringTable, compactCapacityBudget, compactDeterministicTemplates, compactWithoutFields as withoutFields, } from "./compact-authoring-support.js";
+import { applyCompactSharedStructures } from "./compact-shared-structure-authoring.js";
+import { semanticCompactSharedStructureTargets } from "./semantic-fact-compact-support.js";
+export function createSemanticFactCompactCarrier(manifestInput) {
+    const manifest = normalizedMaterializedManifest(manifestInput);
+    const inputRevisionsByFact = indexSemanticFactRevisionInputs(manifest.inputs);
+    const factRevisionByKey = new Map(manifest.facts.map((fact) => [
+        fact.key,
+        semanticFactRevisionDigest(fact, inputRevisionsByFact),
+    ]));
+    const proofRecords = manifest.proof_obligations;
+    const proofFamilies = compactDeterministicTemplates(proofRecords, ["key", "fact_ref", "comparison", "counterfactual"], "proof-template");
+    const proofFamilyByKey = new Map(proofFamilies.templates.map((template) => [template.key, template.value]));
+    const base = {
+        schema_version: "semantic-fact-compact-carrier-v1",
+        key: manifest.key,
+        capacity: {},
+        scope: structuredClone(manifest.scope),
+        inspector: {
+            trust: manifest.inspector.trust,
+            identity: manifest.inspector.identity,
+            version: manifest.inspector.version,
+            implementation_sha256: manifest.inspector.implementation_sha256,
+            capabilities: structuredClone(manifest.inspector.capabilities),
+            traversal: manifest.inspector.traversal,
+            dynamic_discovery: manifest.inspector.dynamic_discovery,
+        },
+        selectors: [],
+        shared_structures: [],
+        catalogs: {
+            inputs: compactTable(manifest.inputs),
+            family_dispositions: compactTable(manifest.family_dispositions),
+            subjects: compactTable(manifest.subjects),
+            relations: compactTable(manifest.relations),
+            populations: compactTable(manifest.populations),
+            axis_dispositions: compactTable(manifest.axis_dispositions),
+            condition_rules: compactTable(manifest.condition_rules),
+            conditions: compactTable(manifest.conditions),
+            condition_exclusions: compactTable(manifest.condition_exclusions),
+            property_dispositions: compactTable(manifest.property_dispositions),
+            fact_cells: compactTable(manifest.fact_cells),
+            oracles: compactTable(manifest.oracles),
+            environments: compactTable(manifest.environments),
+            blockers: compactTable(manifest.blockers),
+        },
+        fact_sets: [
+            {
+                key: "fact-set.complete-source",
+                ...compactTable(manifest.facts.map((fact) => ({
+                    fact_revision_digest: semanticFactRevisionDigest(fact, inputRevisionsByFact),
+                    ...fact,
+                })), ["key"]),
+            },
+        ],
+        proof_templates: proofFamilies.templates.map((template) => ({
+            key: template.key,
+            proof: template.value,
+        })),
+        obligations: compactTable(manifest.proof_obligations.map((proof, index) => ({
+            obligation_key: proof.key,
+            obligation_revision_digest: semanticObligationRevisionDigest(proof, requiredFactRevision(factRevisionByKey, proof.fact_ref)),
+            fact_key: proof.fact_ref,
+            template_ref: proofFamilies.template_refs[index],
+            overrides: withoutFields(proof, [
+                "key",
+                "fact_ref",
+                ...Object.keys(proofFamilyByKey.get(proofFamilies.template_refs[index])),
+            ]),
+        }))),
+        exceptions: [],
+    };
+    const { value: compact, selectors } = applyCompactAuthoringSelectors(base);
+    compact.selectors = selectors;
+    const structures = applyCompactSharedStructures(semanticCompactSharedStructureTargets(compact));
+    compact.shared_structures = structures.catalog;
+    const measured = {
+        inputs: manifest.inputs.length,
+        catalog_rows: manifest.inputs.length +
+            manifest.family_dispositions.length +
+            manifest.subjects.length +
+            manifest.relations.length +
+            manifest.populations.length +
+            manifest.axis_dispositions.length +
+            manifest.condition_rules.length +
+            manifest.conditions.length +
+            manifest.condition_exclusions.length +
+            manifest.property_dispositions.length +
+            manifest.fact_cells.length +
+            manifest.oracles.length +
+            manifest.environments.length +
+            manifest.blockers.length,
+        selector_members: selectors.reduce((sum, selector) => sum + selector.members.length, 0),
+        structure_families: structures.statistics.emitted_family_count,
+        structure_references: structures.statistics.reference_count,
+        structure_arguments: structures.statistics.argument_count,
+        facts: manifest.facts.length,
+        obligations: manifest.proof_obligations.length,
+        census: manifest.inspector.census.length,
+        canonical_bytes: Buffer.byteLength(canonicalValueJson(manifest), "utf8"),
+    };
+    compact.capacity = {
+        theoretical_ground_universe: "not_materialized",
+        measured,
+        maximum: Object.fromEntries(Object.entries(measured).map(([name, count]) => [
+            name,
+            compactCapacityBudget(name, count),
+        ])),
+    };
+    return compact;
+}
+function requiredFactRevision(revisions, factRef) {
+    const revision = revisions.get(factRef);
+    if (!revision)
+        throw new Error(`semantic_fact_compact_authoring_fact_revision_missing:${factRef}`);
+    return revision;
+}
+function normalizedMaterializedManifest(input) {
+    const manifest = structuredClone(input);
+    manifest.inspector.census = buildSemanticFactInspectorCensus(manifest);
+    const rows = {
+        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,
+    };
+    manifest.generation = {
+        strategy: "complete_explicit",
+        sampling: "forbidden",
+        truncation: "forbidden",
+        chunk_count: 1,
+        chunk_indexes: [0],
+        collections: Object.entries(rows).map(([name, collection]) => ({
+            name: name,
+            expected_count: collection.length,
+            identity_sha256: semanticFactCollectionIdentity(collection),
+        })),
+    };
+    return manifest;
+}
+function compactTable(input, excludedDefaults = []) {
+    return compactAuthoringTable(input, excludedDefaults);
+}

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

@@ -0,0 +1,9 @@
+export declare const SEMANTIC_COMPACT_CAPACITY_FIELDS: readonly ["inputs", "catalog_rows", "selector_members", "structure_families", "structure_references", "structure_arguments", "facts", "obligations", "census", "canonical_bytes"];
+type CapacityField = (typeof SEMANTIC_COMPACT_CAPACITY_FIELDS)[number];
+export type SemanticCompactCapacityCounts = Record<CapacityField, number>;
+export declare function validateSemanticCompactCapacity(capacity: {
+    measured: SemanticCompactCapacityCounts;
+    maximum: SemanticCompactCapacityCounts;
+}, measured: SemanticCompactCapacityCounts, label: string): void;
+export declare function validateSemanticCompactDeclaredMaximum(maximum: SemanticCompactCapacityCounts, label: string): void;
+export {};

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;