project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-semantic-assurance-policy.d.ts

@@ -1,4 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-type Reporter = (message: string) => void;
-export declare function validateSemanticAssuranceShape(contract: DeliveryContractV2, report?: Reporter): void;
-export {};

package/dist/lib/long-task-semantic-assurance-policy.js

@@ -1,52 +0,0 @@
-export function validateSemanticAssuranceShape(contract, report) {
-    if (contract.task.context_snapshot_mode !== "full")
-        issue(report, "long_task_full_context_required", contract.task.context_snapshot_mode);
-    validateApplicabilityScope("GLOBAL", contract.global.applicability, report);
-    for (const outcome of contract.outcomes)
-        validateApplicabilityScope(outcome.key, outcome.applicability, report);
-}
-function validateApplicabilityScope(scope, profiles, report) {
-    if (!profiles.length)
-        return;
-    let expectedDimensionKeys = null;
-    const cells = new Map();
-    for (const profile of profiles) {
-        if (!profile.dimensions.length)
-            issue(report, "applicability_dimensions_required", `${scope}:${profile.key}`);
-        const keys = profile.dimensions.map((dimension) => dimension.key);
-        if (new Set(keys).size !== keys.length)
-            issue(report, "applicability_dimension_duplicate", `${scope}:${profile.key}`);
-        const sortedKeys = [...keys].sort();
-        if (expectedDimensionKeys === null)
-            expectedDimensionKeys = sortedKeys;
-        else if (!same(expectedDimensionKeys, sortedKeys))
-            issue(report, "applicability_dimension_set_mismatch", `${scope}:${profile.key}:${expectedDimensionKeys.join(",")}:${sortedKeys.join(",")}`);
-        const dimensions = [...profile.dimensions]
-            .sort((left, right) => left.key.localeCompare(right.key))
-            .map((dimension) => `${dimension.key}=${dimension.value}`)
-            .join(",");
-        const cell = [
-            profile.target_ref,
-            profile.journey_role,
-            dimensions,
-            [...profile.given_refs].sort().join(","),
-            profile.when_refs.join(","),
-        ].join("|");
-        const owner = cells.get(cell);
-        if (owner)
-            issue(report, "applicability_cell_duplicate", `${scope}:${profile.key}:${owner}`);
-        else
-            cells.set(cell, profile.key);
-    }
-}
-function same(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
-function issue(report, code, detail) {
-    const message = `delivery_contract_invalid:${code}:${detail}`;
-    if (report)
-        report(message);
-    else
-        throw new Error(message);
-}

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

@@ -1,54 +0,0 @@
-import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
-export type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
-export interface KeyedStatementV2 {
-    key: string;
-    statement: string;
-}
-export interface ApplicableKeyedStatementV2 extends KeyedStatementV2 {
-    applicability_refs: string[];
-}
-export type ExternalConfirmationKindV2 = "functional_prerequisite" | "field_validation" | "production_release_gate" | "commercial_activation" | "expert_authority";
-export type TargetCompletionStateV2 = "implementation_complete" | "target_profile_usable" | "production_release_ready";
-export type ExecutionTargetRuntimeFamilyV2 = "browser" | "native" | "desktop" | "service" | "process" | "external";
-export interface TargetProfileV2 {
-    key: string;
-    description: string;
-    required_state: TargetCompletionStateV2;
-    required_target_refs: string[];
-}
-export interface ExecutionTargetV2 {
-    key: string;
-    description: string;
-    role: "product" | "support" | "observer";
-    runtime_family: ExecutionTargetRuntimeFamilyV2;
-    root_entrypoint: string;
-    root_argv?: string[];
-    capabilities: ExecutionTargetCapabilityV2[];
-}
-export interface DeliveryStageV2 {
-    key: string;
-    title: string;
-    depends_on: string[];
-    gate_outcome: string;
-}
-export type DeliveryJourneyRoleV2 = "success" | "degradation" | "recovery" | "stage_gate" | "conformance";
-export interface ClaimApplicabilityV2 {
-    key: string;
-    target_ref: string;
-    journey_role: DeliveryJourneyRoleV2;
-    dimensions: Array<{
-        key: string;
-        value: string;
-    }>;
-    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" | "design_symbolic_certificate" | "semantic_fact" | "target_runtime" | "input_variation";
-export interface CheckExecutionTargetV2 {
-    target_ref: string;
-    entrypoint: "root" | "internal";
-}
-export interface DeliveryScenarioV2 {
-    given: KeyedStatementV2[];
-    when: KeyedStatementV2[];
-}

package/dist/lib/long-task-semantic-contract-types.js

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

package/dist/lib/long-task-semantic-drift-migration.d.ts

@@ -1,3 +0,0 @@
-export declare function semanticDriftMigrationFields(value: unknown): string[];
-export declare function semanticDriftOutcomeMigrationFields(value: unknown, label: string): string[];
-export declare function assertNoSemanticDriftMigration(fields: string[]): void;

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

@@ -1,104 +0,0 @@
-export function semanticDriftMigrationFields(value) {
-    const root = row(value);
-    if (!root || root.schema_version !== "long-task-delivery-v2")
-        return [];
-    const 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);
-        if (Object.hasOwn(task, "context_snapshot_mode") &&
-            task.context_snapshot_mode !== "full")
-            missing.push("task.context_snapshot_mode=full");
-        for (const [index, target] of rows(task.execution_targets).entries())
-            required(target, `task.execution_targets[${index}]`, ["capabilities"], missing);
-        const profile = row(task.target_profile);
-        if (profile)
-            required(profile, "task.target_profile", ["required_target_refs"], missing);
-    }
-    for (const [index, outcome] of rows(root.outcomes).entries())
-        collectOutcome(outcome, `outcomes[${index}]`, missing);
-    const global = row(root.global);
-    collectApplicability(global?.applicability, "global.applicability", missing);
-    const globalAcceptance = row(global?.acceptance);
-    collectChecks(globalAcceptance?.checks, "global.acceptance.checks", missing);
-    for (const [index, confirmation] of rows(globalAcceptance?.external_confirmations).entries())
-        required(confirmation, `global.acceptance.external_confirmations[${index}]`, ["kind", "impact_claims", "blocks_target"], missing);
-    return [...new Set(missing)].sort();
-}
-export function semanticDriftOutcomeMigrationFields(value, label) {
-    const missing = [];
-    const outcome = row(value);
-    if (outcome)
-        collectOutcome(outcome, label, missing);
-    return [...new Set(missing)].sort();
-}
-export function assertNoSemanticDriftMigration(fields) {
-    if (!fields.length)
-        return;
-    const detail = fields.slice(0, 24).join(",");
-    const suffix = fields.length > 24 ? `,+${fields.length - 24}-more` : "";
-    throw new Error(`long_task_delivery_v2_semantic_drift_migration_required:${detail}${suffix}`);
-}
-function collectOutcome(outcome, label, missing) {
-    required(outcome, label, ["stage", "applicability", "semantic_fact_bindings"], missing);
-    collectApplicability(outcome.applicability, `${label}.applicability`, missing);
-    const product = row(outcome.product);
-    if (product) {
-        required(product, `${label}.product`, ["success_path_required", "degradation_path_required"], missing);
-        if (Array.isArray(product.controls) &&
-            product.controls.length > 0 &&
-            !Object.hasOwn(product, "surface_bindings"))
-            missing.push(`${label}.product.surface_bindings`);
-        const relationClosure = row(product.control_relation_closure);
-        if (relationClosure && relationClosure.state !== "unresolved")
-            required(relationClosure, `${label}.product.control_relation_closure`, ["applicability_refs"], missing);
-    }
-    const acceptance = row(outcome.acceptance);
-    collectChecks(acceptance?.checks, `${label}.acceptance.checks`, missing);
-    const population = row(acceptance?.population);
-    if (population) {
-        required(population, `${label}.acceptance.population`, ["universe_binding_key"], missing);
-        const observations = row(population.observations);
-        if (observations)
-            required(observations, `${label}.acceptance.population.observations`, ["universe_ids"], missing);
-    }
-    for (const [bindingIndex, binding] of rows(product?.surface_bindings).entries()) {
-        for (const [blockerIndex, blocker] of rows(binding.acceptance_blockers).entries())
-            required(blocker, `${label}.product.surface_bindings[${bindingIndex}].acceptance_blockers[${blockerIndex}]`, ["required_capabilities"], missing);
-        for (const [targetIndex, target] of rows(binding.design_targets).entries())
-            for (const [methodIndex, method] of rows(target.verification_method_bindings).entries()) {
-                required(method, `${label}.product.surface_bindings[${bindingIndex}].design_targets[${targetIndex}].verification_method_bindings[${methodIndex}]`, ["evidence_artifacts"], missing);
-                for (const [artifactIndex, artifact] of rows(method.evidence_artifacts).entries())
-                    required(artifact, `${label}.product.surface_bindings[${bindingIndex}].design_targets[${targetIndex}].verification_method_bindings[${methodIndex}].evidence_artifacts[${artifactIndex}]`, ["observation_path", "fact_refs"], missing);
-            }
-    }
-}
-function collectApplicability(value, label, missing) {
-    for (const [index, profile] of rows(value).entries())
-        required(profile, `${label}[${index}]`, ["dimensions"], missing);
-}
-function collectChecks(value, label, missing) {
-    for (const [index, check] of rows(value).entries()) {
-        const checkLabel = `${label}[${index}]`;
-        required(check, checkLabel, ["journey_roles", "execution_target", "scenario"], missing);
-        for (const polarity of ["positive_assertions", "negative_assertions"])
-            for (const [assertionIndex, assertion] of rows(check[polarity]).entries())
-                required(assertion, `${checkLabel}.${polarity}[${assertionIndex}]`, ["evidence_capabilities"], missing);
-    }
-}
-function required(value, label, keys, missing) {
-    for (const key of keys)
-        if (!Object.hasOwn(value, key))
-            missing.push(`${label}.${key}`);
-}
-function rows(value) {
-    return Array.isArray(value)
-        ? value.map(row).filter((item) => item !== null)
-        : [];
-}
-function row(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}

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

@@ -1,65 +0,0 @@
-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;
-    fact_revision_digest?: string;
-    claim_ref: string;
-    applicability_ref: string;
-}
-export type SemanticFactProofBindingV2 = {
-    proof_ref: string;
-    obligation_revision_digest?: string;
-    fact_ref: string;
-    method: string;
-    proof_surface: ProofSurface;
-    evidence_capabilities: EvidenceCapabilityV2[];
-    authority: "machine";
-    check_ref: string;
-    assertion_ref: string;
-} | {
-    proof_ref: string;
-    obligation_revision_digest?: 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_key: string;
-    fact_revision_digest: string;
-    obligation_key: string;
-    obligation_revision_digest: string;
-    revision_identity_required: boolean;
-    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

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

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

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

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

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

@@ -1,51 +0,0 @@
-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, new Map(parsed.fact_revisions.map((item) => [item.key, item.revision_digest])), new Map(parsed.obligation_revisions.map((item) => [
-        item.key,
-        item.revision_digest,
-    ])), parsed.carrier === "compact_v1");
-    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

@@ -1,4 +0,0 @@
-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, factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, sourceRequiresRevisions: boolean): Map<string, SemanticFactExpectationV2[]>;

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

@@ -1,36 +0,0 @@
-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, factRevisions, obligationRevisions, sourceRequiresRevisions) {
-    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;
-        const revisionsRequired = sourceRequiresRevisions ||
-            bindings.facts.some((item) => item.fact_revision_digest !== undefined) ||
-            bindings.proofs.some((item) => item.obligation_revision_digest !== undefined);
-        assertSameSemanticFactClosureSet(bindings.facts.map((item) => item.fact_ref), facts.map((item) => item.key), `contract_fact_set:${outcome.key}`);
-        if (revisionsRequired) {
-            assertSameSemanticFactClosureSet(bindings.facts.map((item) => revisionPair(item.fact_ref, item.fact_revision_digest, `contract_fact_revision:${outcome.key}`)), facts.map((item) => revisionPair(item.key, factRevisions.get(item.key), `source_fact_revision:${outcome.key}`)), `contract_fact_revision_set:${outcome.key}`);
-            assertSameSemanticFactClosureSet(bindings.proofs.map((item) => revisionPair(item.proof_ref, item.obligation_revision_digest, `contract_obligation_revision:${outcome.key}`)), proofs.map((item) => revisionPair(item.key, obligationRevisions.get(item.key), `source_obligation_revision:${outcome.key}`)), `contract_obligation_revision_set:${outcome.key}`);
-        }
-        assertSameSemanticFactClosureSet(bindings.proofs.map((item) => item.proof_ref), proofs.map((item) => item.key), `contract_proof_set:${outcome.key}`);
-        uniqueSemanticFactClosureValues(bindings.proofs
-            .filter((item) => item.authority === "machine")
-            .map((item) => `${item.check_ref}\0${item.assertion_ref}`), `contract_proof_target:${outcome.key}`);
-        validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired);
-        validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired);
-    }
-    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;
-}
-function revisionPair(key, digest, label) {
-    if (!digest)
-        throw new Error(`semantic_fact_closure_invalid:${label}:${key}:missing`);
-    return `${key}\0${digest}`;
-}

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

@@ -1,4 +0,0 @@
-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[], factRevisions: Map<string, string>, revisionsRequired: boolean): void;

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

@@ -1,33 +0,0 @@
-import { semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired) {
-    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 (revisionsRequired &&
-            binding.fact_revision_digest !== factRevisions.get(binding.fact_ref))
-            semanticFactClosureInvalid("contract_fact_revision_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.fact_revision_digest ?? "missing"}:${factRevisions.get(binding.fact_ref) ?? "missing"}`);
-        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

@@ -1,4 +0,0 @@
-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[], factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, revisionsRequired: boolean): void;

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

@@ -1,106 +0,0 @@
-import { sameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired) {
-    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}`);
-        if (revisionsRequired &&
-            binding.obligation_revision_digest !==
-                obligationRevisions.get(binding.proof_ref))
-            semanticFactClosureInvalid("contract_obligation_revision_mismatch", `${outcome.key}:${binding.proof_ref}:${binding.obligation_revision_digest ?? "missing"}:${obligationRevisions.get(binding.proof_ref) ?? "missing"}`);
-        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, factRevisions, obligationRevisions, revisionsRequired);
-        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, factRevisions, obligationRevisions, revisionsRequired) {
-    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_key: fact.key,
-        fact_revision_digest: factRevisions.get(fact.key),
-        obligation_key: proof.key,
-        obligation_revision_digest: obligationRevisions.get(proof.key),
-        revision_identity_required: revisionsRequired,
-        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

@@ -1,25 +0,0 @@
-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;
-type SemanticFactExactComparisonMaterial = {
-    fact_ref: string;
-    proof_ref: string;
-    fact_key?: string;
-    fact_revision_digest?: string;
-    obligation_key?: string;
-    obligation_revision_digest?: 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;
-};
-export declare function semanticFactComparisonResultIdentity(value: SemanticFactExactComparisonMaterial): string;
-export declare function validateDistinctSemanticFactEvidence(records: EvidenceCapabilityRecordV2[]): string | null;
-export declare const typed_semantic_fact_runtime_evidence = "obligation_key+obligation_revision_digest->fact_key+fact_revision_digest+actual+comparison+verdict+oracle+environment";
-export {};