project-tiny-context-harness 0.8.4 → 0.8.6

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

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

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

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

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

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

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

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

@@ -0,0 +1,46 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
+import { canonicalValueJson, parseStrictYaml, sha256Hex, } from "./strict-codec.js";
+const START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
+const END = /^\s*```[ \t]*$/u;
+export function parseSemanticFactManifestBlocks(sourcePath, content) {
+    const rows = [];
+    const lines = content.replace(/\r\n?/gu, "\n").split("\n");
+    let open = null;
+    for (const [index, line] of lines.entries()) {
+        if (!open) {
+            if (START.test(line))
+                open = { line: index + 1, lines: [] };
+            continue;
+        }
+        if (!END.test(line)) {
+            open.lines.push(line);
+            continue;
+        }
+        const manifest = parseSemanticFactManifestShape(parseStrictYaml(open.lines.join("\n")));
+        rows.push({
+            source_path: sourcePath,
+            line: open.line,
+            manifest,
+            sha256: sha256Hex(canonicalValueJson(manifest)),
+        });
+        open = null;
+    }
+    if (open)
+        throw new Error(`source_formal_block_unclosed:${sourcePath}:semantic-fact-manifest-v1:${open.line}`);
+    return rows;
+}
+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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+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;
+}