project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/long-task-playwright-evidence.js

@@ -1,4 +1,6 @@
 import { collectCases, declaredCaseIds, duplicateCaseInstance, record, same, } from "./long-task-playwright-case-evidence.js";
+import { evidenceRecordsForPlaywrightCases } from "./long-task-playwright-capability-records.js";
+export { designMethodAttachmentName, semanticFactAttachmentName, } from "./long-task-playwright-capability-records.js";
 export function extractPlaywrightEvidence(check, report, exitCode) {
     const stats = record(report.stats);
     if (!stats)
@@ -62,78 +64,11 @@ export function extractPlaywrightEvidence(check, report, exitCode) {
         }
     }
     observations["playwright.case_ids"] = cases.map((item) => item.id).sort();
-    const evidenceRecords = evidenceRecordsForCases(check, cases);
-    return { observations, evidence_records: evidenceRecords, error: null };
-}
-function evidenceRecordsForCases(check, cases) {
-    const evidenceRecords = [];
-    for (const item of cases) {
-        const assertion = [
-            ...check.positive_assertions,
-            ...check.negative_assertions,
-        ].find((candidate) => candidate.key === item.id);
-        if (assertion?.evidence_capabilities.includes("interaction_trace") &&
-            item.executed)
-            evidenceRecords.push({
-                assertion_key: assertion.key,
-                capability: "interaction_trace",
-                target_ref: check.execution_target.target_ref,
-                given_keys: item.given_keys,
-                action_keys: item.action_keys,
-            });
-        if (assertion?.evidence_capabilities.includes("target_runtime") &&
-            item.executed)
-            evidenceRecords.push({
-                assertion_key: assertion.key,
-                capability: "target_runtime",
-                target_ref: check.execution_target.target_ref,
-                root_entrypoint: check.execution_target_definition.root_entrypoint,
-                session_id: `playwright:${item.id}:${item.project_ids.join(",")}`,
-                cold_start: check.execution_target.entrypoint === "root",
-            });
-        if (assertion?.evidence_capabilities.includes("design_conformance") &&
-            item.executed) {
-            for (const target of (check.design_conformance_targets ?? []).filter((candidate) => candidate.conformance_assertion_ref === assertion.key ||
-                candidate.verification_method_bindings.some((binding) => binding.assertion_ref === assertion.key)))
-                evidenceRecords.push({
-                    assertion_key: assertion.key,
-                    capability: "design_conformance",
-                    design_target_ref: target.key,
-                    target_ref: target.target_ref,
-                    condition_keys: target.condition_keys,
-                    actual_artifact_path: target.actual_artifact_path,
-                    comparison_artifact_path: target.comparison_artifact_path,
-                });
-        }
-        if (assertion?.evidence_capabilities.includes("design_method") &&
-            item.executed) {
-            for (const target of check.design_conformance_targets ?? []) {
-                const binding = target.verification_method_bindings.find((candidate) => candidate.assertion_ref === assertion.key);
-                if (!binding)
-                    continue;
-                const requiredAttachments = binding.evidence_artifacts.flatMap((artifact) => [
-                    designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "record"),
-                    designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "observation"),
-                ]);
-                if (!requiredAttachments.every((name) => item.attachment_names.includes(name)))
-                    continue;
-                evidenceRecords.push({
-                    assertion_key: assertion.key,
-                    capability: "design_method",
-                    design_target_ref: target.key,
-                    target_ref: target.target_ref,
-                    method: binding.method,
-                    cells: binding.evidence_artifacts.map((artifact) => ({
-                        condition_key: artifact.condition_key,
-                        artifact_path: artifact.path,
-                        observation_artifact_path: artifact.observation_path,
-                        fact_refs: artifact.fact_refs,
-                    })),
-                });
-            }
-        }
-    }
-    return evidenceRecords;
+    return {
+        observations,
+        evidence_records: evidenceRecordsForPlaywrightCases(check, cases),
+        error: null,
+    };
 }
 function aggregateCases(instances) {
     const grouped = new Map();
@@ -197,13 +132,13 @@ function aggregateCases(instances) {
             attachment_names: rows.length === 0
                 ? []
                 : rows[0].attachment_names.filter((name) => rows.every((row) => row.attachment_names.includes(name))),
+            attachment_payloads: rows.length === 0
+                ? {}
+                : Object.fromEntries(Object.entries(rows[0].attachment_payloads).filter(([name, value]) => rows.every((row) => row.attachment_payloads[name] === value))),
         };
     })
         .sort((left, right) => left.id.localeCompare(right.id));
 }
-export function designMethodAttachmentName(target, method, condition, kind) {
-    return `ty-context-design-method:${target}:${method}:${condition}:${kind}`;
-}
 function integer(value) {
     return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
 }

package/dist/lib/long-task-runner-freeze.d.ts

@@ -1,2 +1,2 @@
-import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[]): Promise<CompiledCheckV2>;
+import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, SemanticFactExpectationV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[]): Promise<CompiledCheckV2>;

package/dist/lib/long-task-runner-freeze.js

@@ -8,7 +8,7 @@ import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
 import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
 import { freezeLocalVerifierDependencyClosure, packageScriptVerifierRoots, } from "./long-task-verifier-dependency-closure.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets) {
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations) {
     const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
     const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
     for (const [index, pattern] of check.input_paths.entries()) {
@@ -24,6 +24,7 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         throw new Error(`runner_cwd_not_found:${check.key}:${check.runner.cwd}`);
     const target = await resolvedRunnerTarget(check, repository, cwd);
     const verificationInputHashes = await freezeVerificationInputs(check, repository, baseline, cwd, target);
+    validateSemanticFactOracleInputs(check.key, semanticFactExpectations, verificationInputHashes);
     const compiled = {
         ...check,
         internal_id: `${prefix}.${check.key}`,
@@ -34,12 +35,25 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         execution_target_definition: executionTarget,
         known_execution_targets: knownExecutionTargets,
         design_conformance_targets: designConformanceTargets,
+        semantic_fact_expectations: semanticFactExpectations,
     };
     return {
         ...compiled,
         raw_execution_identity: computeRawExecutionIdentity(compiled),
     };
 }
+function validateSemanticFactOracleInputs(checkKey, expectations, verificationInputHashes) {
+    const frozenOracles = new Map(expectations
+        .filter((expectation) => expectation.oracle.trust === "frozen_executable")
+        .map((expectation) => [expectation.oracle.key, expectation.oracle]));
+    for (const oracle of frozenOracles.values()) {
+        const frozenSha256 = verificationInputHashes[oracle.identity];
+        if (!frozenSha256)
+            throw new Error(`semantic_fact_oracle_verification_input_missing:${checkKey}:${oracle.key}:${oracle.identity}`);
+        if (frozenSha256 !== oracle.sha256)
+            throw new Error(`semantic_fact_oracle_verification_input_mismatch:${checkKey}:${oracle.key}:${oracle.identity}`);
+    }
+}
 async function resolvedRunnerTarget(check, repository, cwd) {
     if (check.runner.type === "package_script") {
         const packageFile = await nearestRunnerFile(cwd, repository, "package.json");

package/dist/lib/long-task-runtime-types.d.ts

@@ -5,6 +5,7 @@ import type { AuthorityHashesV2, ContextAuthoritySnapshotV2, InitialTaskBaseV2,
 import type { EvidenceAdapter } from "./long-task-evidence-adapter-types.js";
 import type { EvidenceCapabilityRecordV2 } from "./long-task-evidence-capability-types.js";
 import type { EffectiveRiskLevel, RiskFactName } from "./long-task-risk-types.js";
+import type { SemanticFactExpectationV2 } from "./semantic-fact-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
 export interface FrozenRunnerV2 extends DeliveryRunnerV2 {
@@ -27,12 +28,13 @@ export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     execution_target_definition: ExecutionTargetV2;
     known_execution_targets: ExecutionTargetV2[];
     design_conformance_targets: CompiledDesignTargetV2[];
+    semantic_fact_expectations: SemanticFactExpectationV2[];
 }
 export interface ProductClaimV2 {
     id: string;
     outcome_key: string;
     local_key: string;
-    kind: "result" | "requirement" | "control" | "control_relation" | "non_completing" | "obligation" | "forbidden_shortcut";
+    kind: "result" | "requirement" | "control" | "control_relation" | "non_completing" | "obligation" | "semantic_fact" | "forbidden_shortcut";
     required_proof_surfaces: ProofSurface[];
     required_polarity: "positive" | "negative";
     applicability_refs: string[];
@@ -99,6 +101,7 @@ export interface CompiledDeliveryContractV2 {
     authority_materials: NextAuthorityMaterialsV2;
     authority_revision: number;
     claim_coverage: ClaimCoverageSummaryV2;
+    semantic_fact_manifest: DeliveryContractV2["semantic_fact_manifest"];
     task: DeliveryContractV2["task"];
     risk: DeliveryContractV2["risk"];
     source_claims: DeliveryContractV2["source_claims"];

package/dist/lib/long-task-semantic-contract-types.d.ts

@@ -42,7 +42,7 @@ export interface ClaimApplicabilityV2 {
     given_refs: string[];
     when_refs: string[];
 }
-export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "target_runtime" | "input_variation";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "semantic_fact" | "target_runtime" | "input_variation";
 export interface CheckExecutionTargetV2 {
     target_ref: string;
     entrypoint: "root" | "internal";

package/dist/lib/long-task-semantic-drift-migration.js

@@ -3,7 +3,7 @@ export function semanticDriftMigrationFields(value) {
     if (!root || root.schema_version !== "long-task-delivery-v2")
         return [];
     const missing = [];
-    required(root, "$", ["stages"], missing);
+    required(root, "$", ["stages", "semantic_fact_manifest"], missing);
     const task = row(root.task);
     if (task) {
         required(task, "task", ["target_profile", "execution_targets", "context_snapshot_mode"], missing);
@@ -41,7 +41,7 @@ export function assertNoSemanticDriftMigration(fields) {
     throw new Error(`long_task_delivery_v2_semantic_drift_migration_required:${detail}${suffix}`);
 }
 function collectOutcome(outcome, label, missing) {
-    required(outcome, label, ["stage", "applicability"], missing);
+    required(outcome, label, ["stage", "applicability", "semantic_fact_bindings"], missing);
     collectApplicability(outcome.applicability, `${label}.applicability`, missing);
     const product = row(outcome.product);
     if (product) {

package/dist/lib/long-task-semantic-fact-binding-types.d.ts

@@ -0,0 +1,57 @@
+import type { EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
+import type { SemanticFactLocatedValueV1 } from "./semantic-fact-base-types.js";
+import type { SemanticFactEnvironmentV1, SemanticFactOracleV1, SemanticFactProofObligationV1 } from "./semantic-fact-proof-types.js";
+export interface SemanticFactManifestRefV2 {
+    key: string;
+    source_path: string;
+    sha256: string;
+}
+export interface SemanticFactBindingV2 {
+    fact_ref: string;
+    claim_ref: string;
+    applicability_ref: string;
+}
+export type SemanticFactProofBindingV2 = {
+    proof_ref: string;
+    fact_ref: string;
+    method: string;
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    authority: "machine";
+    check_ref: string;
+    assertion_ref: string;
+} | {
+    proof_ref: string;
+    fact_ref: string;
+    method: string;
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    authority: "external_confirmation";
+    confirmation_ref: string;
+};
+export interface SemanticFactOutcomeBindingsV2 {
+    manifest_ref: string;
+    facts: SemanticFactBindingV2[];
+    proofs: SemanticFactProofBindingV2[];
+}
+export interface SemanticFactExpectationV2 {
+    manifest_ref: string;
+    manifest_sha256: string;
+    fact_ref: string;
+    proof_ref: string;
+    method: string;
+    check_ref: string;
+    assertion_ref: string;
+    outcome_ref: string;
+    claim_ref: string;
+    applicability_ref: string;
+    subject_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    observation_sensitivity: "plain" | "protected";
+    expected: SemanticFactLocatedValueV1;
+    comparison: SemanticFactProofObligationV1["comparison"];
+    oracle: SemanticFactOracleV1;
+    environment: SemanticFactEnvironmentV1;
+    observer_refs: string[];
+}

package/dist/lib/long-task-semantic-fact-binding-types.js

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

package/dist/lib/long-task-semantic-fact-closure-primitives.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveSemanticFactPointer(value: unknown, pointer: string, label: string): unknown;
+export declare function uniqueSemanticFactClosureValues(values: string[], label: string): void;
+export declare function sameSemanticFactClosureSet(left: string[], right: string[]): boolean;
+export declare function assertSameSemanticFactClosureSet(left: string[], right: string[], label: string): void;
+export declare function semanticFactClosureInvalid(code: string, detail: unknown): never;

package/dist/lib/long-task-semantic-fact-closure-primitives.js

@@ -0,0 +1,43 @@
+export function resolveSemanticFactPointer(value, pointer, label) {
+    if (pointer === "")
+        return value;
+    if (!pointer.startsWith("/"))
+        semanticFactClosureInvalid("located_value_pointer_invalid", `${label}:${pointer}`);
+    let current = value;
+    for (const segment of pointer
+        .slice(1)
+        .split("/")
+        .map((item) => item.replaceAll("~1", "/").replaceAll("~0", "~"))) {
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9][0-9]*)$/u.test(segment))
+                semanticFactClosureInvalid("located_value_pointer_invalid", `${label}:${pointer}`);
+            current = current[Number(segment)];
+        }
+        else if (current && typeof current === "object")
+            current = current[segment];
+        else
+            current = undefined;
+        if (current === undefined)
+            semanticFactClosureInvalid("located_value_pointer_missing", `${label}:${pointer}`);
+    }
+    return current;
+}
+export function uniqueSemanticFactClosureValues(values, label) {
+    if (new Set(values).size !== values.length)
+        semanticFactClosureInvalid(`${label}_duplicate`, values.join(","));
+}
+export function sameSemanticFactClosureSet(left, right) {
+    return (left.length === right.length &&
+        new Set(left).size === left.length &&
+        left.every((item) => right.includes(item)));
+}
+export function assertSameSemanticFactClosureSet(left, right, label) {
+    if (!sameSemanticFactClosureSet(left, right))
+        semanticFactClosureInvalid(label, {
+            expected: [...right].sort(),
+            actual: [...left].sort(),
+        });
+}
+export function semanticFactClosureInvalid(code, detail) {
+    throw new Error(`semantic_fact_closure_invalid:${code}:${typeof detail === "string" ? detail : JSON.stringify(detail)}`);
+}

package/dist/lib/long-task-semantic-fact-closure.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import { semanticFactCollectionIdentity } from "./semantic-fact-policy.js";
+import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export interface LongTaskSemanticFactClosureV2 {
+    manifest: SemanticFactManifestV1;
+    manifest_sha256: string;
+    manifest_source_path: string;
+    expectations_by_check: Map<string, SemanticFactExpectationV2[]>;
+}
+export declare function validateLongTaskSemanticFactClosure(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[], contextFiles: string[]): Promise<LongTaskSemanticFactClosureV2>;
+export declare const semantic_fact_manifest = "semantic-fact-manifest-v1";
+export declare const semantic_fact_contract_projection_enabled = true;
+export declare const expected_semantic_fact_universe: typeof semanticFactCollectionIdentity;

package/dist/lib/long-task-semantic-fact-closure.js

@@ -0,0 +1,48 @@
+import { validateSemanticFactContractProjection } from "./long-task-semantic-fact-contract-closure.js";
+import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
+import { collectDesignOwnedSemanticFactSourceItems, validateSemanticFactInputInventory, } from "./long-task-semantic-fact-input-closure.js";
+import { validateSemanticFactBasisClosure } from "./long-task-semantic-fact-provenance-closure.js";
+import { validateSemanticFactLocatedValues } from "./long-task-semantic-fact-value-closure.js";
+import { semanticFactCollectionIdentity, validateSemanticFactManifestPolicy, } from "./semantic-fact-policy.js";
+import { loadSemanticFactManifest } from "./semantic-fact-source-parser.js";
+export async function validateLongTaskSemanticFactClosure(contract, repository, sourceItems, contextFiles) {
+    const parsed = await loadSemanticFactManifest(repository, contract.task.source_paths);
+    const manifest = parsed.manifest;
+    const index = validateSemanticFactManifestPolicy(manifest);
+    validateManifestReference(contract, parsed);
+    const designOwnedSourceItems = await collectDesignOwnedSemanticFactSourceItems(repository, contract.task.source_paths);
+    await validateSemanticFactInputInventory(repository, sourceItems, contextFiles, manifest, designOwnedSourceItems);
+    validateSemanticFactBasisClosure(manifest, sourceItems);
+    await validateSemanticFactLocatedValues(repository, manifest, sourceItems);
+    const expectations = validateSemanticFactContractProjection(contract, manifest, index);
+    return {
+        manifest,
+        manifest_sha256: parsed.sha256,
+        manifest_source_path: parsed.source_path,
+        expectations_by_check: expectations,
+    };
+}
+function validateManifestReference(contract, parsed) {
+    const declared = contract.semantic_fact_manifest;
+    if (declared.key !== parsed.manifest.key ||
+        declared.source_path !== parsed.source_path ||
+        declared.sha256 !== parsed.sha256)
+        semanticFactClosureInvalid("manifest_identity_mismatch", {
+            expected: declared,
+            actual: {
+                key: parsed.manifest.key,
+                source_path: parsed.source_path,
+                sha256: parsed.sha256,
+            },
+        });
+    if (!contract.task.source_paths.includes(declared.source_path))
+        semanticFactClosureInvalid("manifest_source_not_declared", declared.source_path);
+    assertSameSemanticFactClosureSet(parsed.manifest.scope.outcome_refs, contract.outcomes.map((item) => item.key), "manifest_outcome_universe");
+    for (const outcome of contract.outcomes)
+        if (outcome.semantic_fact_bindings.manifest_ref !==
+            contract.semantic_fact_manifest.key)
+            semanticFactClosureInvalid("outcome_manifest_ref_mismatch", `${outcome.key}:${outcome.semantic_fact_bindings.manifest_ref}`);
+}
+export const semantic_fact_manifest = "semantic-fact-manifest-v1";
+export const semantic_fact_contract_projection_enabled = true;
+export const expected_semantic_fact_universe = semanticFactCollectionIdentity;

package/dist/lib/long-task-semantic-fact-contract-closure.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
+import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactContractProjection(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1): Map<string, SemanticFactExpectationV2[]>;

package/dist/lib/long-task-semantic-fact-contract-closure.js

@@ -0,0 +1,24 @@
+import { validateSemanticFactOutcomeBindings } from "./long-task-semantic-fact-contract-facts.js";
+import { validateSemanticFactProofBindings } from "./long-task-semantic-fact-contract-proofs.js";
+import { assertSameSemanticFactClosureSet, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
+export function validateSemanticFactContractProjection(contract, manifest, index) {
+    const expectations = new Map();
+    const allFactBindings = [];
+    const allProofBindings = [];
+    const targetByRef = new Map(contract.task.execution_targets.map((item) => [item.key, item]));
+    for (const outcome of contract.outcomes) {
+        const facts = manifest.facts.filter((item) => item.outcome_ref === outcome.key);
+        const proofs = manifest.proof_obligations.filter((proof) => facts.some((fact) => fact.key === proof.fact_ref));
+        const bindings = outcome.semantic_fact_bindings;
+        assertSameSemanticFactClosureSet(bindings.facts.map((item) => item.fact_ref), facts.map((item) => item.key), `contract_fact_set:${outcome.key}`);
+        assertSameSemanticFactClosureSet(bindings.proofs.map((item) => item.proof_ref), proofs.map((item) => item.key), `contract_proof_set:${outcome.key}`);
+        uniqueSemanticFactClosureValues(bindings.proofs.map((item) => item.authority === "machine"
+            ? `${item.check_ref}\0${item.assertion_ref}`
+            : `external\0${item.confirmation_ref}`), `contract_proof_target:${outcome.key}`);
+        validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings);
+        validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings);
+    }
+    assertSameSemanticFactClosureSet(allFactBindings, manifest.facts.map((item) => item.key), "contract_all_fact_set");
+    assertSameSemanticFactClosureSet(allProofBindings, manifest.proof_obligations.map((item) => item.key), "contract_all_proof_set");
+    return expectations;
+}

package/dist/lib/long-task-semantic-fact-contract-facts.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactOutcomeBindings(outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, allFactBindings: string[]): void;

package/dist/lib/long-task-semantic-fact-contract-facts.js

@@ -0,0 +1,30 @@
+import { semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
+export function validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings) {
+    uniqueSemanticFactClosureValues(outcome.semantic_fact_bindings.facts.map((item) => item.claim_ref), `contract_fact_claim:${outcome.key}`);
+    const applicabilityRefs = new Set(outcome.applicability.map((item) => item.key));
+    for (const binding of outcome.semantic_fact_bindings.facts) {
+        const fact = index.fact_by_ref.get(binding.fact_ref);
+        const expectedClaim = `semantic_fact.${binding.fact_ref}`;
+        if (binding.claim_ref !== expectedClaim)
+            semanticFactClosureInvalid("contract_fact_claim_identity_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.claim_ref}:${expectedClaim}`);
+        if (!applicabilityRefs.has(binding.applicability_ref))
+            semanticFactClosureInvalid("contract_fact_applicability_unknown", `${outcome.key}:${binding.fact_ref}:${binding.applicability_ref}`);
+        validateSemanticFactApplicabilityProjection(manifest, fact, outcome.applicability.find((item) => item.key === binding.applicability_ref));
+        if (fact.outcome_ref !== outcome.key)
+            semanticFactClosureInvalid("contract_fact_outcome_mismatch", `${outcome.key}:${binding.fact_ref}`);
+        allFactBindings.push(binding.fact_ref);
+    }
+}
+function validateSemanticFactApplicabilityProjection(manifest, fact, applicability) {
+    const condition = manifest.conditions.find((item) => item.key === fact.condition_ref);
+    if (!condition)
+        semanticFactClosureInvalid("contract_fact_condition_unknown", `${fact.key}:${fact.condition_ref}`);
+    for (const assignment of condition.axis_values) {
+        const axis = manifest.axis_dispositions.find((item) => item.key === assignment.axis_ref);
+        if (!axis)
+            semanticFactClosureInvalid("contract_fact_condition_axis_unknown", `${fact.key}:${assignment.axis_ref}`);
+        if (!applicability.dimensions.some((dimension) => dimension.key === axis.axis &&
+            dimension.value === assignment.value_ref))
+            semanticFactClosureInvalid("contract_fact_applicability_condition_mismatch", `${fact.key}:${applicability.key}:${axis.axis}:${assignment.value_ref}`);
+    }
+}

package/dist/lib/long-task-semantic-fact-contract-proofs.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryContractV2, ExecutionTargetV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
+import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactProofBindings(contract: DeliveryContractV2, outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, targetByRef: Map<string, ExecutionTargetV2>, expectations: Map<string, SemanticFactExpectationV2[]>, allProofBindings: string[]): void;

package/dist/lib/long-task-semantic-fact-contract-proofs.js

@@ -0,0 +1,97 @@
+import { sameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
+export function validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings) {
+    for (const binding of outcome.semantic_fact_bindings.proofs) {
+        const proof = index.proof_by_ref.get(binding.proof_ref);
+        const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
+        if (!factBinding)
+            semanticFactClosureInvalid("contract_proof_fact_binding_missing", `${outcome.key}:${binding.proof_ref}:${binding.fact_ref}`);
+        validateProofIdentity(outcome, proof, binding);
+        validateObserverTargets(proof, binding, targetByRef);
+        if (binding.authority === "external_confirmation")
+            validateExternalProofProjection(contract, outcome, binding, factBinding.claim_ref);
+        else
+            validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations);
+        allProofBindings.push(binding.proof_ref);
+    }
+}
+function validateProofIdentity(outcome, proof, binding) {
+    if (proof.fact_ref !== binding.fact_ref ||
+        proof.method !== binding.method ||
+        proof.proof_surface !== binding.proof_surface ||
+        proof.authority !== binding.authority ||
+        !sameSemanticFactClosureSet(proof.evidence_capabilities, binding.evidence_capabilities))
+        semanticFactClosureInvalid("contract_proof_identity_mismatch", `${outcome.key}:${binding.proof_ref}`);
+}
+function validateObserverTargets(proof, binding, targetByRef) {
+    for (const observerRef of proof.observer_refs)
+        if (!targetByRef.has(observerRef))
+            semanticFactClosureInvalid("proof_observer_target_unknown", `${binding.proof_ref}:${observerRef}`);
+        else if (targetByRef.get(observerRef).role !== "observer")
+            semanticFactClosureInvalid("proof_observer_target_role_mismatch", `${binding.proof_ref}:${observerRef}:${targetByRef.get(observerRef).role}`);
+}
+function validateExternalProofProjection(contract, outcome, binding, claimRef) {
+    const confirmation = contract.global.acceptance.external_confirmations.find((item) => item.key === binding.confirmation_ref);
+    const fullClaim = `${outcome.key}.${claimRef}`;
+    if (!confirmation)
+        semanticFactClosureInvalid("semantic_fact_confirmation_unknown", `${binding.proof_ref}:${binding.confirmation_ref}`);
+    if (!confirmation.impact_claims.includes(fullClaim))
+        semanticFactClosureInvalid("semantic_fact_confirmation_lineage_missing", `${binding.confirmation_ref}:${fullClaim}`);
+}
+function validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations) {
+    const check = outcome.acceptance.checks.find((item) => item.key === binding.check_ref);
+    if (!check)
+        semanticFactClosureInvalid("semantic_fact_check_unknown", `${outcome.key}:${binding.check_ref}`);
+    for (const observerRef of proof.observer_refs)
+        if (observerRef === check.execution_target.target_ref)
+            semanticFactClosureInvalid("proof_observer_not_independent", `${binding.proof_ref}:${observerRef}`);
+    if (check.proof_surface !== binding.proof_surface)
+        semanticFactClosureInvalid("semantic_fact_check_surface_mismatch", `${binding.proof_ref}:${check.proof_surface}:${binding.proof_surface}`);
+    const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
+    if (!assertion)
+        semanticFactClosureInvalid("semantic_fact_assertion_unknown", `${binding.check_ref}:${binding.assertion_ref}`);
+    if (assertion.claims.length !== 1 ||
+        assertion.claims[0] !== factBinding.claim_ref ||
+        assertion.applicability_ref !== factBinding.applicability_ref ||
+        assertion.operator !== "equals" ||
+        assertion.expected !== true ||
+        !sameSemanticFactClosureSet(assertion.evidence_capabilities, binding.evidence_capabilities))
+        semanticFactClosureInvalid("semantic_fact_assertion_binding_mismatch", `${binding.check_ref}:${binding.assertion_ref}`);
+    validateSemanticFactCounterfactualProjection(outcome, proof, factBinding.claim_ref, binding.check_ref, binding.assertion_ref);
+    const fact = index.fact_by_ref.get(binding.fact_ref);
+    const rows = expectations.get(binding.check_ref) ?? [];
+    rows.push({
+        manifest_ref: manifest.key,
+        manifest_sha256: contract.semantic_fact_manifest.sha256,
+        fact_ref: fact.key,
+        proof_ref: proof.key,
+        method: proof.method,
+        check_ref: binding.check_ref,
+        assertion_ref: binding.assertion_ref,
+        outcome_ref: outcome.key,
+        claim_ref: factBinding.claim_ref,
+        applicability_ref: factBinding.applicability_ref,
+        subject_ref: fact.unit_ref,
+        condition_ref: fact.condition_ref,
+        property_ref: fact.property_ref,
+        observation_sensitivity: fact.observation_sensitivity,
+        expected: fact.expected,
+        comparison: proof.comparison,
+        oracle: index.oracle_by_ref.get(proof.oracle_ref),
+        environment: index.environment_by_ref.get(proof.environment_ref),
+        observer_refs: proof.observer_refs,
+    });
+    expectations.set(binding.check_ref, rows);
+}
+function validateSemanticFactCounterfactualProjection(outcome, proof, claimRef, checkRef, assertionRef) {
+    if (proof.counterfactual.disposition !== "required")
+        return;
+    for (const counterfactualRef of proof.counterfactual.refs) {
+        const counterfactual = outcome.acceptance.counterfactual_controls.find((item) => item.key === counterfactualRef);
+        if (!counterfactual)
+            semanticFactClosureInvalid("semantic_fact_counterfactual_unknown", `${proof.key}:${counterfactualRef}`);
+        if (counterfactual.check_key !== checkRef ||
+            !counterfactual.claims.includes(claimRef) ||
+            !counterfactual.expected_assertion_failures.includes(assertionRef))
+            semanticFactClosureInvalid("semantic_fact_counterfactual_binding_mismatch", `${proof.key}:${counterfactualRef}`);
+    }
+}

package/dist/lib/long-task-semantic-fact-evidence.d.ts

@@ -0,0 +1,21 @@
+import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+type SemanticRecord = Extract<EvidenceCapabilityRecordV2, {
+    capability: "semantic_fact";
+}>;
+export declare function validateSemanticFactEvidence(check: CompiledCheckV2, record: SemanticRecord, artifactHashes: Record<string, string>): string | null;
+export declare function semanticFactComparisonResultIdentity(value: {
+    fact_ref: string;
+    proof_ref: string;
+    target_ref: string;
+    actual_value_sha256: string;
+    expected_value_sha256: string;
+    comparator: string;
+    mode: "exact" | "tolerance";
+    parameters_sha256: string;
+    tolerance_sha256: string | null;
+    mask_sha256: string | null;
+    passed: boolean;
+}): string;
+export declare function validateDistinctSemanticFactEvidence(records: EvidenceCapabilityRecordV2[]): string | null;
+export declare const typed_semantic_fact_runtime_evidence = "fact_ref+actual+comparison+verdict+oracle+environment";
+export {};