project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-scoped-binding.js

@@ -1,11 +0,0 @@
-export function scopeDeliveryBinding(outcomeKey, binding) {
-    return {
-        outcome_key: outcomeKey,
-        local_key: binding.key,
-        binding_ref: `${outcomeKey}.${binding.key}`,
-        binding,
-    };
-}
-export function scopeDeliveryBindings(outcomeKey, bindings) {
-    return bindings.map((binding) => scopeDeliveryBinding(outcomeKey, binding));
-}

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,43 +0,0 @@
-import { canonicalApplicabilityIdentity } from "./long-task-applicability-identity.js";
-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 cell = canonicalApplicabilityIdentity(profile);
-        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,55 +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[];
-    completion_authority: "machine_only" | "declared_authorities";
-}
-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" | "actual_provenance" | "external_side_effect" | "distinct_identity" | "data_state" | "population_coverage" | "failure_injection" | "recovery" | "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,150 +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);
-    const externalConfirmations = rows(globalAcceptance?.external_confirmations);
-    for (const [index, confirmation] of externalConfirmations.entries())
-        collectExternalConfirmation(confirmation, `global.acceptance.external_confirmations[${index}]`, missing);
-    if (externalConfirmations.some((confirmation) => confirmation.blocks_target === true) &&
-        row(task?.target_profile)?.completion_authority !== "declared_authorities")
-        missing.push("task.target_profile.completion_authority=declared_authorities_or_remove_blocking_external");
-    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 collectExternalConfirmation(confirmation, label, missing) {
-    required(confirmation, label, ["kind", "impact_claims", "blocks_target"], missing);
-    if (confirmation.blocks_target !== true)
-        return;
-    required(confirmation, label, [
-        "actor",
-        "target_ref",
-        "environment_identity",
-        "scenario",
-        "evidence_requirements",
-        "obligations",
-    ], missing);
-    const actor = row(confirmation.actor);
-    if (actor) {
-        required(actor, `${label}.actor`, ["identity_assurance"], missing);
-        const assurance = row(actor.identity_assurance);
-        if (assurance) {
-            required(assurance, `${label}.actor.identity_assurance`, ["scheme"], missing);
-            if (assurance.scheme !== "ed25519")
-                missing.push(`${label}.actor.identity_assurance.scheme=ed25519`);
-            else
-                required(assurance, `${label}.actor.identity_assurance`, ["key_id", "public_key_ref"], missing);
-        }
-    }
-    for (const [index, obligation] of rows(confirmation.obligations).entries()) {
-        const obligationLabel = `${label}.obligations[${index}]`;
-        required(obligation, obligationLabel, [
-            "key",
-            "claim_ref",
-            "applicability_ref",
-            "fact_ref",
-            "proof_ref",
-            "method",
-            "proof_surface",
-            "evidence_capabilities",
-            "expected_authority_ref",
-            "result_kind",
-        ], missing);
-        if (obligation.result_kind === "judgment")
-            required(obligation, obligationLabel, ["judgment_basis"], 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,85 +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;
-    required_polarity?: "positive" | "negative";
-}
-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 SemanticFactGlobalObligationBindingV2 {
-    claim_ref: string;
-    applicability_ref: string;
-    target_ref: string;
-    outcome_ref: string;
-    fact_ref: string;
-    proof_ref: string;
-    method: string;
-    required_polarity: "positive" | "negative";
-}
-/**
- * Links Global Claims to exact obligations that remain owned by the existing
- * Outcome-scoped Semantic Fact/proof bindings. This is a conservation
- * projection, not a second Fact inventory or completion authority.
- */
-export interface SemanticFactGlobalBindingsV2 {
-    manifest_ref: string;
-    obligations: SemanticFactGlobalObligationBindingV2[];
-}
-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,17 +0,0 @@
-import type { LongTaskDesignHandoffPreflight } from "./long-task-design-resource-handoff.js";
-import { type SourceSemanticConservationV2 } from "./long-task-source-conservation.js";
-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";
-import type { CapturedContextGraphSnapshot } from "./context-graph-snapshot.js";
-export interface LongTaskSemanticFactClosureV2 {
-    manifest: SemanticFactManifestV1;
-    manifest_sha256: string;
-    manifest_source_path: string;
-    expectations_by_check: Map<string, SemanticFactExpectationV2[]>;
-    source_conservation: SourceSemanticConservationV2;
-}
-export declare function validateLongTaskSemanticFactClosure(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[], context: CapturedContextGraphSnapshot, designHandoffs?: LongTaskDesignHandoffPreflight[]): 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,79 +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, projectDesignOwnedSemanticFacts, 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 { validateSourceSemanticConservation, } from "./long-task-source-conservation.js";
-import { semanticFactCollectionIdentity, validateSemanticFactManifestPolicy, } from "./semantic-fact-policy.js";
-import { loadSemanticFactManifest } from "./semantic-fact-source-parser.js";
-export async function validateLongTaskSemanticFactClosure(contract, repository, sourceItems, context, designHandoffs) {
-    const parsed = await loadSemanticFactManifest(repository, contract.task.source_paths);
-    const manifest = parsed.manifest;
-    validateManifestReference(contract, parsed);
-    const designProjection = designHandoffs
-        ? projectDesignOwnedSemanticFacts(designHandoffs)
-        : {
-            source_items: await collectDesignOwnedSemanticFactSourceItems(repository, contract.task.source_paths),
-            facts: [],
-        };
-    const index = validateSemanticFactManifestPolicy(manifest, new Set(designProjection.facts.map((fact) => fact.key)));
-    const materialInputs = await validateSemanticFactInputInventory(repository, sourceItems, context, manifest, designProjection);
-    const sourceConservation = validateSourceSemanticConservation(sourceItems, manifest, designProjection, materialInputs, semanticFactClaimPolarities(contract));
-    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,
-        source_conservation: sourceConservation,
-    };
-}
-function semanticFactClaimPolarities(contract) {
-    const result = new Map();
-    for (const outcome of contract.outcomes)
-        for (const binding of outcome.semantic_fact_bindings.facts) {
-            const values = result.get(binding.fact_ref) ?? new Set();
-            values.add(binding.required_polarity ?? "positive");
-            result.set(binding.fact_ref, values);
-        }
-    for (const binding of contract.global.semantic_fact_bindings?.obligations ??
-        []) {
-        const values = result.get(binding.fact_ref) ?? new Set();
-        values.add(binding.required_polarity);
-        result.set(binding.fact_ref, values);
-    }
-    return result;
-}
-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}`);
-    if (contract.global.semantic_fact_bindings &&
-        contract.global.semantic_fact_bindings.manifest_ref !==
-            contract.semantic_fact_manifest.key)
-        semanticFactClosureInvalid("global_manifest_ref_mismatch", contract.global.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[]>;