project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,146 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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-condition-shape.d.ts

@@ -1,48 +0,0 @@
-export declare function parseSemanticFactAxisDispositions(value: unknown, label: string): {
-    key: string;
-    axis: string;
-    standard: boolean;
-    disposition: "applicable" | "decision_required" | "not_applicable" | "unavailable";
-    outcome_refs: string[];
-    values: {
-        key: string;
-        source_item_refs: string[];
-        basis_refs: string[];
-    }[];
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}[];
-export declare function parseSemanticFactConditionRules(value: unknown, label: string): {
-    key: string;
-    outcome_ref: string;
-    axis_refs: string[];
-    mode: "cross_product" | "explicit_meaningful" | "independent";
-    condition_refs: string[];
-    exclusion_refs: string[];
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}[];
-export declare function parseSemanticFactConditions(value: unknown, label: string): {
-    key: string;
-    outcome_ref: string;
-    axis_values: {
-        axis_ref: string;
-        value_ref: string;
-    }[];
-    source_item_refs: string[];
-    basis_refs: string[];
-}[];
-export declare function parseSemanticFactConditionExclusions(value: unknown, label: string): {
-    key: string;
-    outcome_ref: string;
-    axis_values: {
-        axis_ref: string;
-        value_ref: string;
-    }[];
-    disposition: "decision_required" | "not_applicable" | "unavailable";
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}[];