project-tiny-context-harness 0.8.3 → 0.8.5

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

@@ -0,0 +1,121 @@
+import { EVIDENCE_CAPABILITIES, PROOF_SURFACES, } from "./long-task-shape-primitives.js";
+import { SEMANTIC_FACT_VALUE_KINDS } from "./semantic-fact-shape-constants.js";
+import { semanticArray, semanticLiteral, semanticNullable, semanticNullableNumber, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
+export function parseSemanticFacts(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "cell_ref",
+            "outcome_ref",
+            "unit_ref",
+            "family_ref",
+            "condition_ref",
+            "property_ref",
+            "owner_ref",
+            "value_kind",
+            "observation_scope",
+            "observation_sensitivity",
+            "quantifier",
+            "expected",
+            "provenance",
+            "source_item_refs",
+        ]);
+        const quantifier = semanticObject(row.quantifier, `${itemLabel}.quantifier`, ["kind", "minimum", "maximum", "population_ref"]);
+        const provenance = semanticObject(row.provenance, `${itemLabel}.provenance`, ["kind", "authority_ref", "basis_refs", "derivation"]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            cell_ref: semanticStableRef(row.cell_ref, `${itemLabel}.cell_ref`),
+            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
+            unit_ref: semanticStableRef(row.unit_ref, `${itemLabel}.unit_ref`),
+            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
+            condition_ref: semanticStableRef(row.condition_ref, `${itemLabel}.condition_ref`),
+            property_ref: semanticStableRef(row.property_ref, `${itemLabel}.property_ref`),
+            owner_ref: semanticStableRef(row.owner_ref, `${itemLabel}.owner_ref`),
+            value_kind: semanticLiteral(row.value_kind, SEMANTIC_FACT_VALUE_KINDS, `${itemLabel}.value_kind`),
+            observation_scope: semanticLiteral(row.observation_scope, [
+                "product_boundary",
+                "service_boundary",
+                "data_boundary",
+                "security_boundary",
+                "operational_boundary",
+                "implementation_structure",
+                "external_boundary",
+            ], `${itemLabel}.observation_scope`),
+            observation_sensitivity: semanticLiteral(row.observation_sensitivity, ["plain", "protected"], `${itemLabel}.observation_sensitivity`),
+            quantifier: {
+                kind: semanticLiteral(quantifier.kind, [
+                    "one",
+                    "all",
+                    "any",
+                    "none",
+                    "exactly",
+                    "at_least",
+                    "at_most",
+                    "range",
+                ], `${itemLabel}.quantifier.kind`),
+                minimum: semanticNullableNumber(quantifier.minimum, `${itemLabel}.quantifier.minimum`),
+                maximum: semanticNullableNumber(quantifier.maximum, `${itemLabel}.quantifier.maximum`),
+                population_ref: semanticNullable(quantifier.population_ref, (entry) => semanticStableRef(entry, `${itemLabel}.quantifier.population_ref`)),
+            },
+            expected: parseSemanticFactLocatedValue(row.expected, `${itemLabel}.expected`),
+            provenance: {
+                kind: semanticLiteral(provenance.kind, [
+                    "direct",
+                    "logically_derived",
+                    "explicitly_delegated",
+                    "evidence_backed_preservation",
+                ], `${itemLabel}.provenance.kind`),
+                authority_ref: semanticStableRef(provenance.authority_ref, `${itemLabel}.provenance.authority_ref`),
+                basis_refs: semanticStableRefs(provenance.basis_refs, `${itemLabel}.provenance.basis_refs`),
+                derivation: semanticNullable(provenance.derivation, (entry) => semanticString(entry, `${itemLabel}.provenance.derivation`)),
+            },
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+        };
+    });
+}
+export function parseSemanticFactProofObligations(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "fact_ref",
+            "method",
+            "authority",
+            "proof_surface",
+            "evidence_capabilities",
+            "comparison",
+            "oracle_ref",
+            "environment_ref",
+            "observer_refs",
+            "counterfactual",
+        ]);
+        const comparison = semanticObject(row.comparison, `${itemLabel}.comparison`, ["comparator", "mode", "parameters", "tolerance", "mask"]);
+        const counterfactual = semanticObject(row.counterfactual, `${itemLabel}.counterfactual`, ["disposition", "refs", "basis_refs", "rationale"]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            fact_ref: semanticStableRef(row.fact_ref, `${itemLabel}.fact_ref`),
+            method: semanticStableRef(row.method, `${itemLabel}.method`),
+            authority: semanticLiteral(row.authority, ["machine", "external_confirmation"], `${itemLabel}.authority`),
+            proof_surface: semanticLiteral(row.proof_surface, PROOF_SURFACES, `${itemLabel}.proof_surface`),
+            evidence_capabilities: semanticArray(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((entry, capabilityIndex) => semanticLiteral(entry, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
+            comparison: {
+                comparator: semanticStableRef(comparison.comparator, `${itemLabel}.comparison.comparator`),
+                mode: semanticLiteral(comparison.mode, ["exact", "tolerance"], `${itemLabel}.comparison.mode`),
+                parameters: parseSemanticFactLocatedValue(comparison.parameters, `${itemLabel}.comparison.parameters`),
+                tolerance: semanticNullable(comparison.tolerance, (entry) => parseSemanticFactLocatedValue(entry, `${itemLabel}.comparison.tolerance`)),
+                mask: semanticNullable(comparison.mask, (entry) => parseSemanticFactLocatedValue(entry, `${itemLabel}.comparison.mask`)),
+            },
+            oracle_ref: semanticStableRef(row.oracle_ref, `${itemLabel}.oracle_ref`),
+            environment_ref: semanticStableRef(row.environment_ref, `${itemLabel}.environment_ref`),
+            observer_refs: semanticStableRefs(row.observer_refs, `${itemLabel}.observer_refs`),
+            counterfactual: {
+                disposition: semanticLiteral(counterfactual.disposition, ["required", "not_applicable", "external"], `${itemLabel}.counterfactual.disposition`),
+                refs: semanticStableRefs(counterfactual.refs, `${itemLabel}.counterfactual.refs`),
+                basis_refs: semanticStableRefs(counterfactual.basis_refs, `${itemLabel}.counterfactual.basis_refs`),
+                rationale: semanticString(counterfactual.rationale, `${itemLabel}.counterfactual.rationale`),
+            },
+        };
+    });
+}

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

@@ -0,0 +1,74 @@
+import type { EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
+import type { SemanticFactAuthorityKind, SemanticFactLocatedValueV1, SemanticFactValueKind } from "./semantic-fact-base-types.js";
+export interface SemanticFactV1 {
+    key: string;
+    cell_ref: string;
+    outcome_ref: string;
+    unit_ref: string;
+    family_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    owner_ref: string;
+    value_kind: SemanticFactValueKind;
+    observation_scope: "product_boundary" | "service_boundary" | "data_boundary" | "security_boundary" | "operational_boundary" | "implementation_structure" | "external_boundary";
+    observation_sensitivity: "plain" | "protected";
+    quantifier: {
+        kind: "one" | "all" | "any" | "none" | "exactly" | "at_least" | "at_most" | "range";
+        minimum: number | null;
+        maximum: number | null;
+        population_ref: string | null;
+    };
+    expected: SemanticFactLocatedValueV1;
+    provenance: {
+        kind: SemanticFactAuthorityKind;
+        authority_ref: string;
+        basis_refs: string[];
+        derivation: string | null;
+    };
+    source_item_refs: string[];
+}
+export interface SemanticFactOracleV1 {
+    key: string;
+    trust: "frozen_executable" | "named_external_tcb";
+    identity: string;
+    version: string;
+    sha256: string | null;
+    capabilities: string[];
+}
+export interface SemanticFactEnvironmentV1 {
+    key: string;
+    identity: string;
+    definition: SemanticFactLocatedValueV1;
+}
+export interface SemanticFactProofObligationV1 {
+    key: string;
+    fact_ref: string;
+    method: string;
+    authority: "machine" | "external_confirmation";
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: SemanticFactLocatedValueV1;
+        tolerance: SemanticFactLocatedValueV1 | null;
+        mask: SemanticFactLocatedValueV1 | null;
+    };
+    oracle_ref: string;
+    environment_ref: string;
+    observer_refs: string[];
+    counterfactual: {
+        disposition: "required" | "not_applicable" | "external";
+        refs: string[];
+        basis_refs: string[];
+        rationale: string;
+    };
+}
+export interface SemanticFactBlockerV1 {
+    key: string;
+    kind: "decision_required" | "unavailable" | "conflict" | "unreadable";
+    affected_refs: string[];
+    source_item_refs: string[];
+    owner: string;
+    resolution: string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+export declare function parseSemanticFactPropertyDispositions(value: unknown, label: string): {
+    key: string;
+    family_ref: string;
+    property: string;
+    standard: boolean;
+    value_kind: "boolean" | "custom" | "decision_table" | "digest" | "duration" | "enum" | "formula" | "number" | "object" | "ordered_list" | "range" | "rate" | "ratio" | "relation" | "schema" | "set" | "string" | "timestamp" | "trace";
+    required_methods: string[];
+    required_evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    applicable_unit_refs: string[];
+    not_applicable_unit_refs: string[];
+    decision_required_unit_refs: string[];
+    unavailable_unit_refs: string[];
+    condition_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactCells(value: unknown, label: string): {
+    key: string;
+    outcome_ref: string;
+    unit_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    disposition: "decision_required" | "not_applicable" | "specified" | "unavailable";
+    fact_ref: string | null;
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];

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[];
+}[];