project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,77 +0,0 @@
-import { EVIDENCE_CAPABILITIES } from "./long-task-shape-primitives.js";
-import { SEMANTIC_FACT_VALUE_KINDS } from "./semantic-fact-shape-constants.js";
-import { semanticArray, semanticLiteral, semanticNullable, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
-import { parseSemanticFactBoolean } from "./semantic-fact-value-shape.js";
-export function parseSemanticFactPropertyDispositions(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "family_ref",
-            "property",
-            "standard",
-            "value_kind",
-            "required_methods",
-            "required_evidence_capabilities",
-            "applicable_unit_refs",
-            "not_applicable_unit_refs",
-            "decision_required_unit_refs",
-            "unavailable_unit_refs",
-            "condition_refs",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
-            property: semanticStableRef(row.property, `${itemLabel}.property`),
-            standard: parseSemanticFactBoolean(row.standard, `${itemLabel}.standard`),
-            value_kind: semanticLiteral(row.value_kind, SEMANTIC_FACT_VALUE_KINDS, `${itemLabel}.value_kind`),
-            required_methods: semanticStableRefs(row.required_methods, `${itemLabel}.required_methods`),
-            required_evidence_capabilities: semanticArray(row.required_evidence_capabilities, `${itemLabel}.required_evidence_capabilities`).map((entry, capabilityIndex) => semanticLiteral(entry, EVIDENCE_CAPABILITIES, `${itemLabel}.required_evidence_capabilities[${capabilityIndex}]`)),
-            applicable_unit_refs: semanticStableRefs(row.applicable_unit_refs, `${itemLabel}.applicable_unit_refs`),
-            not_applicable_unit_refs: semanticStableRefs(row.not_applicable_unit_refs, `${itemLabel}.not_applicable_unit_refs`),
-            decision_required_unit_refs: semanticStableRefs(row.decision_required_unit_refs, `${itemLabel}.decision_required_unit_refs`),
-            unavailable_unit_refs: semanticStableRefs(row.unavailable_unit_refs, `${itemLabel}.unavailable_unit_refs`),
-            condition_refs: semanticStableRefs(row.condition_refs, `${itemLabel}.condition_refs`),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
-            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
-        };
-    });
-}
-export function parseSemanticFactCells(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "outcome_ref",
-            "unit_ref",
-            "condition_ref",
-            "property_ref",
-            "disposition",
-            "fact_ref",
-            "source_item_refs",
-            "basis_refs",
-            "rationale",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
-            unit_ref: semanticStableRef(row.unit_ref, `${itemLabel}.unit_ref`),
-            condition_ref: semanticStableRef(row.condition_ref, `${itemLabel}.condition_ref`),
-            property_ref: semanticStableRef(row.property_ref, `${itemLabel}.property_ref`),
-            disposition: semanticLiteral(row.disposition, [
-                "specified",
-                "not_applicable",
-                "decision_required",
-                "unavailable",
-            ], `${itemLabel}.disposition`),
-            fact_ref: semanticNullable(row.fact_ref, (entry) => semanticStableRef(entry, `${itemLabel}.fact_ref`)),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
-            rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
-        };
-    });
-}

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

@@ -1,3 +0,0 @@
-export declare const SEMANTIC_FACT_DISPOSITIONS: readonly ["applicable", "not_applicable", "decision_required", "unavailable"];
-export declare const SEMANTIC_FACT_VALUE_KINDS: readonly ["boolean", "number", "string", "enum", "set", "ordered_list", "object", "schema", "relation", "decision_table", "formula", "range", "duration", "timestamp", "rate", "ratio", "digest", "trace", "custom"];
-export declare const SEMANTIC_FACT_LOCATOR_KINDS: readonly ["source_item", "manifest_pointer", "json_pointer", "yaml_pointer", "whole_resource", "schema_pointer", "api_operation", "code_symbol", "custom"];

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

@@ -1,38 +0,0 @@
-export const SEMANTIC_FACT_DISPOSITIONS = [
-    "applicable",
-    "not_applicable",
-    "decision_required",
-    "unavailable",
-];
-export const SEMANTIC_FACT_VALUE_KINDS = [
-    "boolean",
-    "number",
-    "string",
-    "enum",
-    "set",
-    "ordered_list",
-    "object",
-    "schema",
-    "relation",
-    "decision_table",
-    "formula",
-    "range",
-    "duration",
-    "timestamp",
-    "rate",
-    "ratio",
-    "digest",
-    "trace",
-    "custom",
-];
-export const SEMANTIC_FACT_LOCATOR_KINDS = [
-    "source_item",
-    "manifest_pointer",
-    "json_pointer",
-    "yaml_pointer",
-    "whole_resource",
-    "schema_pointer",
-    "api_operation",
-    "code_symbol",
-    "custom",
-];

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

@@ -1,15 +0,0 @@
-export type SemanticShape = Record<string, unknown>;
-export declare function semanticObject(value: unknown, label: string, required: string[], optional?: string[]): SemanticShape;
-export declare function semanticArray(value: unknown, label: string): unknown[];
-export declare function semanticString(value: unknown, label: string): string;
-export declare function semanticStrings(value: unknown, label: string): string[];
-export declare function semanticStableRef(value: unknown, label: string): string;
-export declare function semanticStableRefs(value: unknown, label: string): string[];
-export declare function semanticSha256(value: unknown, label: string): string;
-export declare function semanticNullableSha256(value: unknown, label: string): string | null;
-export declare function semanticInteger(value: unknown, label: string, minimum?: number): number;
-export declare function semanticFiniteNumber(value: unknown, label: string): number;
-export declare function semanticNullableNumber(value: unknown, label: string): number | null;
-export declare function semanticLiteral<T extends string>(value: unknown, allowed: readonly T[], label: string): T;
-export declare function semanticNullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
-export declare function semanticFail(label: string, message: string): never;

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

@@ -1,68 +0,0 @@
-export function semanticObject(value, label, required, optional = []) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        semanticFail(label, "must be an object");
-    const row = value;
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(row).filter((key) => !allowed.has(key));
-    if (unknown.length)
-        semanticFail(label, `unknown keys: ${unknown.join(",")}`);
-    const missing = required.filter((key) => !Object.hasOwn(row, key));
-    if (missing.length)
-        semanticFail(label, `missing keys: ${missing.join(",")}`);
-    return row;
-}
-export function semanticArray(value, label) {
-    if (!Array.isArray(value))
-        semanticFail(label, "must be an array");
-    return value;
-}
-export function semanticString(value, label) {
-    if (typeof value !== "string" || !value.trim())
-        semanticFail(label, "must be a non-empty string");
-    return value;
-}
-export function semanticStrings(value, label) {
-    return semanticArray(value, label).map((item, index) => semanticString(item, `${label}[${index}]`));
-}
-export function semanticStableRef(value, label) {
-    const result = semanticString(value, label);
-    if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))
-        semanticFail(label, "must be a stable lowercase reference");
-    return result;
-}
-export function semanticStableRefs(value, label) {
-    return semanticArray(value, label).map((item, index) => semanticStableRef(item, `${label}[${index}]`));
-}
-export function semanticSha256(value, label) {
-    const result = semanticString(value, label);
-    if (!/^[a-f0-9]{64}$/u.test(result))
-        semanticFail(label, "must be a lowercase SHA-256 digest");
-    return result;
-}
-export function semanticNullableSha256(value, label) {
-    return value === null ? null : semanticSha256(value, label);
-}
-export function semanticInteger(value, label, minimum = 0) {
-    if (!Number.isInteger(value) || Number(value) < minimum)
-        semanticFail(label, `must be an integer >= ${minimum}`);
-    return Number(value);
-}
-export function semanticFiniteNumber(value, label) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        semanticFail(label, "must be a finite number");
-    return value;
-}
-export function semanticNullableNumber(value, label) {
-    return value === null ? null : semanticFiniteNumber(value, label);
-}
-export function semanticLiteral(value, allowed, label) {
-    if (typeof value !== "string" || !allowed.includes(value))
-        semanticFail(label, `must be one of ${allowed.join(",")}`);
-    return value;
-}
-export function semanticNullable(value, parser) {
-    return value === null ? null : parser(value);
-}
-export function semanticFail(label, message) {
-    throw new Error(`semantic_fact_manifest_invalid:${label}:${message}`);
-}

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

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

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

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

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

@@ -1,21 +0,0 @@
-export declare function parseSemanticFactOracles(value: unknown, label: string): {
-    key: string;
-    trust: "frozen_executable" | "named_external_tcb";
-    identity: string;
-    version: string;
-    sha256: string | null;
-    capabilities: string[];
-}[];
-export declare function parseSemanticFactEnvironments(value: unknown, label: string): {
-    key: string;
-    identity: string;
-    definition: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1;
-}[];
-export declare function parseSemanticFactBlockers(value: unknown, label: string): {
-    key: string;
-    kind: "conflict" | "decision_required" | "unavailable" | "unreadable";
-    affected_refs: string[];
-    source_item_refs: string[];
-    owner: string;
-    resolution: string;
-}[];

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

@@ -1,59 +0,0 @@
-import { semanticArray, semanticLiteral, semanticNullableSha256, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
-import { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
-export function parseSemanticFactOracles(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "trust",
-            "identity",
-            "version",
-            "sha256",
-            "capabilities",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            trust: semanticLiteral(row.trust, ["frozen_executable", "named_external_tcb"], `${itemLabel}.trust`),
-            identity: semanticString(row.identity, `${itemLabel}.identity`),
-            version: semanticString(row.version, `${itemLabel}.version`),
-            sha256: semanticNullableSha256(row.sha256, `${itemLabel}.sha256`),
-            capabilities: semanticStableRefs(row.capabilities, `${itemLabel}.capabilities`),
-        };
-    });
-}
-export function parseSemanticFactEnvironments(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "identity",
-            "definition",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            identity: semanticString(row.identity, `${itemLabel}.identity`),
-            definition: parseSemanticFactLocatedValue(row.definition, `${itemLabel}.definition`),
-        };
-    });
-}
-export function parseSemanticFactBlockers(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "kind",
-            "affected_refs",
-            "source_item_refs",
-            "owner",
-            "resolution",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            kind: semanticLiteral(row.kind, ["decision_required", "unavailable", "conflict", "unreadable"], `${itemLabel}.kind`),
-            affected_refs: semanticStableRefs(row.affected_refs, `${itemLabel}.affected_refs`),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            owner: semanticString(row.owner, `${itemLabel}.owner`),
-            resolution: semanticString(row.resolution, `${itemLabel}.resolution`),
-        };
-    });
-}

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

@@ -1,5 +0,0 @@
-export * from "./long-task-semantic-fact-binding-types.js";
-export * from "./semantic-fact-base-types.js";
-export * from "./semantic-fact-inventory-types.js";
-export * from "./semantic-fact-manifest-types.js";
-export * from "./semantic-fact-proof-types.js";

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

@@ -1,5 +0,0 @@
-export * from "./long-task-semantic-fact-binding-types.js";
-export * from "./semantic-fact-base-types.js";
-export * from "./semantic-fact-inventory-types.js";
-export * from "./semantic-fact-manifest-types.js";
-export * from "./semantic-fact-proof-types.js";

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

@@ -1,34 +0,0 @@
-export declare function parseSemanticFactSubjects(value: unknown, label: string): {
-    key: string;
-    family_ref: string;
-    outcome_ref: string;
-    kind: string;
-    parent_ref: string | null;
-    owner_ref: string | null;
-    source_item_refs: string[];
-    basis_refs: string[];
-}[];
-export declare function parseSemanticFactRelations(value: unknown, label: string): {
-    key: string;
-    family_ref: string;
-    outcome_ref: string;
-    kind: string;
-    endpoints: {
-        role: string;
-        unit_ref: string;
-    }[];
-    source_item_refs: string[];
-    basis_refs: string[];
-}[];
-export declare function parseSemanticFactPopulations(value: unknown, label: string): {
-    key: string;
-    family_ref: string;
-    outcome_ref: string;
-    kind: "dynamic" | "static";
-    member_unit_refs: string[];
-    universe: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1;
-    enumeration_rule: string;
-    exclusion_refs: string[];
-    source_item_refs: string[];
-    basis_refs: string[];
-}[];

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

@@ -1,89 +0,0 @@
-import { semanticArray, semanticLiteral, semanticNullable, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
-import { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
-export function parseSemanticFactSubjects(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "family_ref",
-            "outcome_ref",
-            "kind",
-            "parent_ref",
-            "owner_ref",
-            "source_item_refs",
-            "basis_refs",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
-            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
-            kind: semanticStableRef(row.kind, `${itemLabel}.kind`),
-            parent_ref: semanticNullable(row.parent_ref, (entry) => semanticStableRef(entry, `${itemLabel}.parent_ref`)),
-            owner_ref: semanticNullable(row.owner_ref, (entry) => semanticStableRef(entry, `${itemLabel}.owner_ref`)),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
-        };
-    });
-}
-export function parseSemanticFactRelations(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "family_ref",
-            "outcome_ref",
-            "kind",
-            "endpoints",
-            "source_item_refs",
-            "basis_refs",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
-            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
-            kind: semanticStableRef(row.kind, `${itemLabel}.kind`),
-            endpoints: semanticArray(row.endpoints, `${itemLabel}.endpoints`).map((endpoint, endpointIndex) => {
-                const endpointLabel = `${itemLabel}.endpoints[${endpointIndex}]`;
-                const entry = semanticObject(endpoint, endpointLabel, [
-                    "role",
-                    "unit_ref",
-                ]);
-                return {
-                    role: semanticStableRef(entry.role, `${endpointLabel}.role`),
-                    unit_ref: semanticStableRef(entry.unit_ref, `${endpointLabel}.unit_ref`),
-                };
-            }),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
-        };
-    });
-}
-export function parseSemanticFactPopulations(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, [
-            "key",
-            "family_ref",
-            "outcome_ref",
-            "kind",
-            "member_unit_refs",
-            "universe",
-            "enumeration_rule",
-            "exclusion_refs",
-            "source_item_refs",
-            "basis_refs",
-        ]);
-        return {
-            key: semanticStableRef(row.key, `${itemLabel}.key`),
-            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
-            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
-            kind: semanticLiteral(row.kind, ["static", "dynamic"], `${itemLabel}.kind`),
-            member_unit_refs: semanticStableRefs(row.member_unit_refs, `${itemLabel}.member_unit_refs`),
-            universe: parseSemanticFactLocatedValue(row.universe, `${itemLabel}.universe`),
-            enumeration_rule: semanticString(row.enumeration_rule, `${itemLabel}.enumeration_rule`),
-            exclusion_refs: semanticStableRefs(row.exclusion_refs, `${itemLabel}.exclusion_refs`),
-            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
-            basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
-        };
-    });
-}

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

@@ -1,12 +0,0 @@
-import type { SemanticFactLocatedValueV1 } from "./semantic-fact-types.js";
-export declare function parseSemanticFactAxisValues(value: unknown, label: string): {
-    axis_ref: string;
-    value_ref: string;
-}[];
-export declare function parseSemanticFactLocatedValue(value: unknown, label: string): SemanticFactLocatedValueV1;
-export declare function parseSemanticFactLocator(value: unknown, label: string): {
-    material_ref: string;
-    kind: "api_operation" | "code_symbol" | "custom" | "json_pointer" | "manifest_pointer" | "schema_pointer" | "source_item" | "whole_resource" | "yaml_pointer";
-    value: string;
-};
-export declare function parseSemanticFactBoolean(value: unknown, label: string): boolean;

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

@@ -1,39 +0,0 @@
-import { SEMANTIC_FACT_LOCATOR_KINDS } from "./semantic-fact-shape-constants.js";
-import { semanticArray, semanticLiteral, semanticObject, semanticSha256, semanticStableRef, semanticString, } from "./semantic-fact-shape-primitives.js";
-export function parseSemanticFactAxisValues(value, label) {
-    return semanticArray(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = semanticObject(item, itemLabel, ["axis_ref", "value_ref"]);
-        return {
-            axis_ref: semanticStableRef(row.axis_ref, `${itemLabel}.axis_ref`),
-            value_ref: semanticStableRef(row.value_ref, `${itemLabel}.value_ref`),
-        };
-    });
-}
-export function parseSemanticFactLocatedValue(value, label) {
-    const preliminary = semanticObject(value, label, ["representation", "locator", "sha256"], ["value"]);
-    const representation = semanticLiteral(preliminary.representation, ["inline", "located", "digest_only"], `${label}.representation`);
-    if (representation === "inline" && !Object.hasOwn(preliminary, "value"))
-        throw new Error(`semantic_fact_manifest_invalid:${label}.value:required for inline representation`);
-    if (representation !== "inline" && Object.hasOwn(preliminary, "value"))
-        throw new Error(`semantic_fact_manifest_invalid:${label}.value:forbidden for ${representation} representation`);
-    return {
-        representation,
-        locator: parseSemanticFactLocator(preliminary.locator, `${label}.locator`),
-        sha256: semanticSha256(preliminary.sha256, `${label}.sha256`),
-        ...(representation === "inline" ? { value: preliminary.value } : {}),
-    };
-}
-export function parseSemanticFactLocator(value, label) {
-    const row = semanticObject(value, label, ["material_ref", "kind", "value"]);
-    return {
-        material_ref: semanticStableRef(row.material_ref, `${label}.material_ref`),
-        kind: semanticLiteral(row.kind, SEMANTIC_FACT_LOCATOR_KINDS, `${label}.kind`),
-        value: semanticString(row.value, `${label}.value`),
-    };
-}
-export function parseSemanticFactBoolean(value, label) {
-    if (typeof value !== "boolean")
-        throw new Error(`semantic_fact_manifest_invalid:${label}:must be boolean`);
-    return value;
-}

package/dist/lib/source-line-scanner.d.ts

@@ -1,3 +0,0 @@
-export type SourceLineVisitor = (line: string, startOffset: number, endOffset: number, nextOffset: number, lineNumber: number) => void;
-export declare function forEachSourceLine(content: string, visit: SourceLineVisitor): void;
-export declare function formalBlockBody(content: string, bodyStartOffset: number, closingLineStartOffset: number, preserveClosingSeparator?: boolean): string;

package/dist/lib/source-line-scanner.js

@@ -1,42 +0,0 @@
-export function forEachSourceLine(content, visit) {
-    let startOffset = 0;
-    let lineNumber = 1;
-    while (startOffset <= content.length) {
-        let endOffset = startOffset;
-        while (endOffset < content.length) {
-            const code = content.charCodeAt(endOffset);
-            if (code === 10 || code === 13)
-                break;
-            endOffset += 1;
-        }
-        let nextOffset = endOffset;
-        if (nextOffset < content.length) {
-            if (content.charCodeAt(nextOffset) === 13 &&
-                content.charCodeAt(nextOffset + 1) === 10)
-                nextOffset += 2;
-            else
-                nextOffset += 1;
-        }
-        visit(content.slice(startOffset, endOffset), startOffset, endOffset, nextOffset, lineNumber);
-        if (endOffset === content.length)
-            break;
-        startOffset = nextOffset;
-        lineNumber += 1;
-    }
-}
-export function formalBlockBody(content, bodyStartOffset, closingLineStartOffset, preserveClosingSeparator = false) {
-    let bodyEndOffset = closingLineStartOffset;
-    if (!preserveClosingSeparator &&
-        bodyEndOffset > bodyStartOffset &&
-        content.charCodeAt(bodyEndOffset - 1) === 10) {
-        bodyEndOffset -= 1;
-        if (bodyEndOffset > bodyStartOffset &&
-            content.charCodeAt(bodyEndOffset - 1) === 13)
-            bodyEndOffset -= 1;
-    }
-    else if (!preserveClosingSeparator &&
-        bodyEndOffset > bodyStartOffset &&
-        content.charCodeAt(bodyEndOffset - 1) === 13)
-        bodyEndOffset -= 1;
-    return content.slice(bodyStartOffset, bodyEndOffset).replace(/\r\n?/gu, "\n");
-}

package/dist/lib/stable-json.d.ts

@@ -1,2 +0,0 @@
-export declare function stableJson(value: unknown): string;
-export declare function sha256(value: string): string;

package/dist/lib/stable-json.js

@@ -1,21 +0,0 @@
-import { createHash } from "node:crypto";
-export function stableJson(value) {
-    return JSON.stringify(sortJson(value), null, 2);
-}
-export function sha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function sortJson(value) {
-    if (Array.isArray(value)) {
-        return value.map(sortJson);
-    }
-    if (!isRecord(value)) {
-        return value;
-    }
-    return Object.fromEntries(Object.keys(value)
-        .sort()
-        .map((key) => [key, sortJson(value[key])]));
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}