project-tiny-context-harness 0.11.0 → 0.12.1

package/dist/lib/long-task-acceptance-reachability-semantic.js

@@ -1,122 +0,0 @@
-import { pendingExternalRow } from "./long-task-acceptance-reachability-helpers.js";
-import { resolveObligationAuthority } from "./long-task-obligation-authority-resolution.js";
-export function compileSemanticFactReachability(input, rows, external) {
-    const facts = new Map(input.manifest.facts.map((fact) => [fact.key, fact]));
-    for (const proof of input.manifest.proof_obligations) {
-        const fact = facts.get(proof.fact_ref);
-        const outcome = input.contract.outcomes.find((item) => item.key === fact.outcome_ref);
-        const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === fact.key);
-        const binding = outcome.semantic_fact_bindings.proofs.find((item) => item.proof_ref === proof.key);
-        const fullClaim = `${outcome.key}.${factBinding.claim_ref}`;
-        const machineCandidates = binding.authority === "machine"
-            ? admittedSemanticMachineRoutes(input, proof.key, outcome.key, binding.check_ref, binding.assertion_ref)
-            : [];
-        const exactExternal = input.contract.global.acceptance.external_confirmations
-            .filter((confirmation) => confirmation.blocks_target &&
-            confirmation.obligations?.some((obligation) => obligation.claim_ref === fullClaim &&
-                obligation.applicability_ref ===
-                    factBinding.applicability_ref &&
-                obligation.fact_ref === fact.key &&
-                obligation.proof_ref === proof.key &&
-                obligation.method === proof.method &&
-                obligation.proof_surface === proof.proof_surface))
-            .map((confirmation) => ({
-            confirmation_ref: confirmation.key,
-            proof_surface: proof.proof_surface,
-        }));
-        const externalCandidates = binding.authority === "external_confirmation"
-            ? uniqueExternalCandidates([
-                ...exactExternal,
-                {
-                    confirmation_ref: binding.confirmation_ref,
-                    proof_surface: proof.proof_surface,
-                },
-            ])
-            : machineCandidates.length
-                ? exactExternal
-                : [];
-        const resolution = resolveObligationAuthority({
-            source_obligation_ref: proof.key,
-            machine_candidates: machineCandidates,
-            external_candidates: externalCandidates,
-        });
-        if (resolution.status === "machine_admitted") {
-            rows.push({
-                obligation_ref: proof.key,
-                source_obligation_ref: proof.key,
-                outcome_key: outcome.key,
-                claim_ref: fullClaim,
-                applicability_ref: factBinding.applicability_ref,
-                fact_ref: fact.key,
-                proof_ref: proof.key,
-                method: proof.method,
-                proof_surface: proof.proof_surface,
-                required_evidence_capabilities: [...proof.evidence_capabilities].sort(),
-                authority: "machine",
-                confirmation_ref: null,
-                status: "machine_admitted",
-                reason: null,
-                session_group: null,
-            });
-            continue;
-        }
-        if (resolution.status === "external_candidate") {
-            const expected = {
-                source_obligation_ref: proof.key,
-                outcome_key: outcome.key,
-                claim_ref: fullClaim,
-                local_claim_ref: factBinding.claim_ref,
-                applicability_ref: factBinding.applicability_ref,
-                fact_ref: fact.key,
-                proof_ref: proof.key,
-                method: proof.method,
-                proof_surface: proof.proof_surface,
-                evidence_capabilities: [...proof.evidence_capabilities].sort(),
-                expected_authority_ref: `semantic-proof:${proof.key}`,
-                confirmation_ref: resolution.external.confirmation_ref,
-                required_polarity: factBinding.required_polarity ?? "positive",
-                completion_role: "blocking",
-                acceptance_effect: "required",
-                semantic_identity: null,
-                machine_obligation_ref: null,
-            };
-            external.push(expected);
-            rows.push(pendingExternalRow(proof.key, outcome.key, fullClaim, factBinding.applicability_ref, fact.key, proof.key, proof.method, proof.proof_surface, expected.evidence_capabilities, expected.confirmation_ref));
-            continue;
-        }
-        rows.push({
-            ...pendingExternalRow(proof.key, outcome.key, fullClaim, factBinding.applicability_ref, fact.key, proof.key, proof.method, proof.proof_surface, [...proof.evidence_capabilities].sort(), null),
-            authority: "none",
-            reason: resolution.reason === "no_admitted_proof_route" &&
-                binding.authority === "machine"
-                ? "machine_observer_not_admitted"
-                : resolution.reason,
-        });
-    }
-}
-function admittedSemanticMachineRoutes(input, proofRef, outcomeKey, checkRef, assertionRef) {
-    return input.compiled_checks.flatMap((check) => check.outcome_key === outcomeKey &&
-        check.key === checkRef &&
-        check.completion_role === "semantic" &&
-        check.observation_authorities.some((authority) => authority.obligation_ref === proofRef &&
-            authority.assertion_ref === assertionRef &&
-            authority.authority !== "external_confirmation")
-        ? [
-            {
-                check_key: checkRef,
-                assertion_key: assertionRef,
-                proof_surface: check.proof_surface,
-                required_evidence_capabilities: check.required_evidence_capabilities[assertionRef] ?? [],
-            },
-        ]
-        : []);
-}
-function uniqueExternalCandidates(candidates) {
-    const seen = new Set();
-    return candidates.filter((candidate) => {
-        if (seen.has(candidate.confirmation_ref))
-            return false;
-        seen.add(candidate.confirmation_ref);
-        return true;
-    });
-}

package/dist/lib/long-task-acceptance-reachability-types.d.ts

@@ -1,91 +0,0 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
-import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export type AcceptanceReachabilityStatusV1 = "machine_admitted" | "external_fulfillable" | "unreachable";
-export interface AcceptanceObligationReachabilityV1 {
-    obligation_ref: string;
-    source_obligation_ref: string;
-    outcome_key: string | null;
-    claim_ref: string;
-    applicability_ref: string;
-    fact_ref: string | null;
-    proof_ref: string | null;
-    method: string;
-    proof_surface: ProofSurface;
-    required_evidence_capabilities: EvidenceCapabilityV2[];
-    authority: "machine" | "external_confirmation" | "none";
-    confirmation_ref: string | null;
-    status: AcceptanceReachabilityStatusV1;
-    reason: string | null;
-    session_group: string | null;
-}
-export interface AcceptanceReachabilityV1 {
-    completion_authority: DeliveryContractV2["task"]["target_profile"]["completion_authority"];
-    total: number;
-    machine_admitted: number;
-    external_fulfillable: number;
-    unreachable: number;
-    obligations: AcceptanceObligationReachabilityV1[];
-    effective_external_routes: EffectiveExternalObligationV1[];
-}
-export interface MachineAuthorityRouteV1 {
-    check_key: string;
-    assertion_key: string;
-    proof_surface: ProofSurface;
-    method?: string;
-    required_evidence_capabilities: EvidenceCapabilityV2[];
-    semantic_identity?: string | null;
-}
-export interface ExternalAuthorityRouteV1 {
-    confirmation_ref: string;
-    obligation_key?: string;
-    proof_surface: ProofSurface;
-    method?: string;
-    required_evidence_capabilities?: EvidenceCapabilityV2[];
-    advisory_to_machine?: boolean;
-    authority_ambiguous?: boolean;
-    authority_unresolved?: boolean;
-    expected_authority_ref?: string;
-    semantic_identity?: string | null;
-}
-export interface ObligationAuthorityCandidatesV1 {
-    source_obligation_ref: string;
-    proof_surface_selection?: "required" | "optional";
-    machine_candidates: MachineAuthorityRouteV1[];
-    external_candidates: ExternalAuthorityRouteV1[];
-}
-export interface ExpectedExternalObligation {
-    source_obligation_ref: string;
-    outcome_key: string | null;
-    claim_ref: string;
-    local_claim_ref: string;
-    applicability_ref: string;
-    fact_ref: string | null;
-    proof_ref: string | null;
-    method: string;
-    proof_surface: ProofSurface;
-    evidence_capabilities: EvidenceCapabilityV2[];
-    expected_authority_ref: string;
-    confirmation_ref: string;
-    required_polarity: "positive" | "negative";
-    completion_role: "blocking" | "advisory";
-    acceptance_effect: "required" | "none";
-    semantic_identity: string | null;
-    machine_obligation_ref: string | null;
-}
-export interface EffectiveExternalObligationV1 extends AcceptanceObligationReachabilityV1 {
-    local_claim_ref: string;
-    target_ref: string;
-    expected_authority_ref: string;
-    required_polarity: "positive" | "negative";
-    completion_role: "blocking" | "advisory";
-    acceptance_effect: "required" | "none";
-    semantic_identity: string;
-    machine_obligation_ref: string | null;
-}
-export interface AcceptanceReachabilityInputV1 {
-    contract: DeliveryContractV2;
-    claims: CompiledClaimsV2;
-    manifest: SemanticFactManifestV1;
-    compiled_checks: CompiledCheckV2[];
-}

package/dist/lib/long-task-acceptance-reachability-types.js

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

package/dist/lib/long-task-acceptance-reachability.d.ts

@@ -1,4 +0,0 @@
-import type { AcceptanceReachabilityInputV1, AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-export type { AcceptanceObligationReachabilityV1, AcceptanceReachabilityStatusV1, AcceptanceReachabilityV1, EffectiveExternalObligationV1, } from "./long-task-acceptance-reachability-types.js";
-export declare function compileAcceptanceReachability(input: AcceptanceReachabilityInputV1): AcceptanceReachabilityV1;
-export declare function assertAcceptanceReachable(reachability: AcceptanceReachabilityV1): void;

package/dist/lib/long-task-acceptance-reachability.js

@@ -1,115 +0,0 @@
-import { compileClaimReachability } from "./long-task-acceptance-reachability-claims.js";
-import { compileDesignFactReachability } from "./long-task-acceptance-reachability-design.js";
-import { addUnboundBlockingConfirmationRows, validateExternalDeclarations, } from "./long-task-acceptance-reachability-external.js";
-import { compileSemanticFactReachability } from "./long-task-acceptance-reachability-semantic.js";
-import { effectiveExternalRouteRef, pendingExternalRow, } from "./long-task-acceptance-reachability-helpers.js";
-import { claimApplicabilityProfile } from "./long-task-applicability-identity.js";
-import { effectiveExternalObligationSemanticIdentity } from "./long-task-obligation-semantic-identity.js";
-export function compileAcceptanceReachability(input) {
-    const rows = [];
-    const expectedExternal = [];
-    compileClaimReachability(input, rows, expectedExternal);
-    compileSemanticFactReachability(input, rows, expectedExternal);
-    compileDesignFactReachability(input, rows, expectedExternal);
-    addUnboundBlockingConfirmationRows(input.contract, rows, expectedExternal);
-    const externalMatches = validateExternalDeclarations(input.contract, input.manifest, expectedExternal, input.compiled_checks);
-    const effectiveExternal = applyExternalReachability(input, rows, expectedExternal, externalMatches);
-    const sorted = rows.sort((left, right) => left.source_obligation_ref.localeCompare(right.source_obligation_ref));
-    return {
-        completion_authority: input.contract.task.target_profile.completion_authority,
-        total: sorted.length,
-        machine_admitted: sorted.filter((row) => row.status === "machine_admitted")
-            .length,
-        external_fulfillable: sorted.filter((row) => row.status === "external_fulfillable").length,
-        unreachable: sorted.filter((row) => row.status === "unreachable").length,
-        obligations: sorted,
-        effective_external_routes: effectiveExternal.sort((left, right) => effectiveExternalRouteRef(left.confirmation_ref, left.source_obligation_ref).localeCompare(effectiveExternalRouteRef(right.confirmation_ref, right.source_obligation_ref))),
-    };
-}
-export function assertAcceptanceReachable(reachability) {
-    const unreachable = reachability.obligations.filter((row) => row.status === "unreachable");
-    if (unreachable.length)
-        throw new Error(`acceptance_obligation_unreachable:${unreachable
-            .map((row) => `${row.source_obligation_ref}:${row.reason}`)
-            .join(",")}`);
-}
-function applyExternalReachability(input, rows, expectedExternal, matches) {
-    const effective = [];
-    for (const expected of expectedExternal) {
-        const row = rows.find((candidate) => candidate.source_obligation_ref === expected.source_obligation_ref &&
-            candidate.confirmation_ref === expected.confirmation_ref);
-        if (expected.completion_role === "blocking" &&
-            input.contract.task.target_profile.completion_authority === "machine_only") {
-            if (row) {
-                row.status = "unreachable";
-                row.reason = "completion_authority_machine_only";
-            }
-            continue;
-        }
-        const match = matches.get(effectiveExternalRouteRef(expected.confirmation_ref, expected.source_obligation_ref));
-        if (!match) {
-            if (row) {
-                row.status = "unreachable";
-                row.reason = "external_confirmation_decomposition_invalid";
-            }
-            else {
-                rows.push({
-                    ...pendingExternalRow(expected.source_obligation_ref, expected.outcome_key, expected.claim_ref, expected.applicability_ref, expected.fact_ref, expected.proof_ref, expected.method, expected.proof_surface, expected.evidence_capabilities, expected.confirmation_ref),
-                    authority: "none",
-                    reason: "external_confirmation_decomposition_invalid",
-                });
-            }
-            continue;
-        }
-        const applicability = claimApplicabilityProfile(input.contract, expected.outcome_key, expected.applicability_ref);
-        if (!applicability) {
-            if (row) {
-                row.status = "unreachable";
-                row.reason = "external_confirmation_decomposition_invalid";
-            }
-            continue;
-        }
-        const semanticIdentity = effectiveExternalObligationSemanticIdentity(input, expected);
-        if (!semanticIdentity) {
-            if (row) {
-                row.status = "unreachable";
-                row.reason = "external_confirmation_decomposition_invalid";
-            }
-            continue;
-        }
-        if (row) {
-            row.obligation_ref = match.obligation_key;
-            row.status = "external_fulfillable";
-            row.reason = null;
-            row.session_group = match.session_group;
-        }
-        effective.push({
-            obligation_ref: match.obligation_key,
-            source_obligation_ref: expected.source_obligation_ref,
-            outcome_key: expected.outcome_key,
-            claim_ref: expected.claim_ref,
-            local_claim_ref: expected.local_claim_ref,
-            applicability_ref: expected.applicability_ref,
-            target_ref: applicability.target_ref,
-            fact_ref: expected.fact_ref,
-            proof_ref: expected.proof_ref,
-            method: expected.method,
-            proof_surface: expected.proof_surface,
-            required_evidence_capabilities: [
-                ...expected.evidence_capabilities,
-            ].sort(),
-            expected_authority_ref: expected.expected_authority_ref,
-            required_polarity: expected.required_polarity,
-            authority: "external_confirmation",
-            confirmation_ref: expected.confirmation_ref,
-            status: "external_fulfillable",
-            reason: null,
-            session_group: match.session_group,
-            completion_role: expected.completion_role,
-            acceptance_effect: expected.acceptance_effect,
-            semantic_identity: semanticIdentity,
-            machine_obligation_ref: expected.machine_obligation_ref,
-        });
-    }
-    return effective;
-}

package/dist/lib/long-task-acceptance-reference.d.ts

@@ -1,22 +0,0 @@
-import type { CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export type AcceptanceReference = {
-    scope: "global";
-    check_key: string;
-    assertion_key: string;
-} | {
-    scope: "outcome";
-    outcome_key: string;
-    check_key: string;
-    assertion_key: string;
-};
-export interface ResolvedAcceptanceAssertion {
-    ref: string;
-    scope: AcceptanceReference["scope"];
-    outcome_key: string | null;
-    check_key: string;
-    assertion_key: string;
-    check: DeliveryCheckV2;
-    assertion: DeliveryAssertionV2;
-}
-export declare function parseAcceptanceReference(ref: string): AcceptanceReference;
-export declare function resolveAcceptanceAssertion(contract: DeliveryContractV2 | CompiledDeliveryContractV2, ref: string): ResolvedAcceptanceAssertion | null;

package/dist/lib/long-task-acceptance-reference.js

@@ -1,46 +0,0 @@
-export function parseAcceptanceReference(ref) {
-    const parts = ref.split(".");
-    if (parts.length !== 3 || parts.some((part) => !part))
-        throw new Error(`acceptance_reference_invalid:${ref}`);
-    const [owner, checkKey, assertionKey] = parts;
-    return owner === "GLOBAL"
-        ? {
-            scope: "global",
-            check_key: checkKey,
-            assertion_key: assertionKey,
-        }
-        : {
-            scope: "outcome",
-            outcome_key: owner,
-            check_key: checkKey,
-            assertion_key: assertionKey,
-        };
-}
-export function resolveAcceptanceAssertion(contract, ref) {
-    let reference;
-    try {
-        reference = parseAcceptanceReference(ref);
-    }
-    catch {
-        return null;
-    }
-    const contractLike = contract;
-    const checks = reference.scope === "global"
-        ? contractLike.global.acceptance.checks
-        : contractLike.outcomes.find((outcome) => outcome.key === reference.outcome_key)?.acceptance.checks;
-    const check = checks?.find((item) => item.key === reference.check_key);
-    const assertion = check
-        ? [...check.positive_assertions, ...check.negative_assertions].find((item) => item.key === reference.assertion_key)
-        : null;
-    if (!check || !assertion)
-        return null;
-    return {
-        ref,
-        scope: reference.scope,
-        outcome_key: reference.scope === "outcome" ? reference.outcome_key : null,
-        check_key: reference.check_key,
-        assertion_key: reference.assertion_key,
-        check,
-        assertion,
-    };
-}

package/dist/lib/long-task-acceptance-shape.d.ts

@@ -1,5 +0,0 @@
-import type { CounterfactualControlV2, EnvironmentRequirementV2, GlobalCounterfactualControlV2, PopulationRequirementV2 } from "./long-task-delivery-types.js";
-export declare function parseCounterfactuals(value: unknown, label: string): CounterfactualControlV2[];
-export declare function parseGlobalCounterfactuals(value: unknown, label: string): GlobalCounterfactualControlV2[];
-export declare function parsePopulation(value: unknown, label: string): PopulationRequirementV2;
-export declare function parseEnvironmentRequirements(value: unknown, label: string): EnvironmentRequirementV2[];

package/dist/lib/long-task-acceptance-shape.js

@@ -1,198 +0,0 @@
-import { parseKeyedStatements } from "./long-task-product-shape.js";
-import { array, fail, key, literal, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
-export function parseCounterfactuals(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "binding_key",
-            "claims",
-            "check_key",
-            "mutation",
-            "expected_assertion_failures",
-        ], ["preserved_assertions", "allowed_fanout_assertions"]);
-        const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], [
-            "paths",
-            "path",
-            "fixture_path",
-            "pointer",
-            "value",
-            "match",
-            "replacement",
-        ]);
-        const type = literal(mutation.type, [
-            "remove_paths",
-            "replace_file",
-            "replace_json_value",
-            "replace_text",
-        ], `${itemLabel}.mutation.type`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            binding_key: key(row.binding_key, `${itemLabel}.binding_key`),
-            claims: strings(row.claims, `${itemLabel}.claims`),
-            check_key: key(row.check_key, `${itemLabel}.check_key`),
-            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
-            expected_assertion_failures: strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((item, assertionIndex) => key(item, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`)),
-            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
-                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
-                : [],
-            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
-                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
-                : [],
-        };
-    });
-}
-export function parseGlobalCounterfactuals(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "binding_ref",
-            "claims",
-            "check_key",
-            "mutation",
-            "expected_assertion_failures",
-        ], ["preserved_assertions", "allowed_fanout_assertions"]);
-        const bindingRef = string(row.binding_ref, `${itemLabel}.binding_ref`);
-        if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(bindingRef))
-            fail(`${itemLabel}.binding_ref`, "must be <outcome-key>.<binding-key>");
-        const claims = strings(row.claims, `${itemLabel}.claims`);
-        if (!claims.length)
-            fail(`${itemLabel}.claims`, "must not be empty");
-        const failures = strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((entry, assertionIndex) => key(entry, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`));
-        if (!failures.length)
-            fail(`${itemLabel}.expected_assertion_failures`, "must not be empty");
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            binding_ref: bindingRef,
-            claims,
-            check_key: key(row.check_key, `${itemLabel}.check_key`),
-            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
-            expected_assertion_failures: failures,
-            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
-                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
-                : [],
-            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
-                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
-                : [],
-        };
-    });
-}
-function parseCounterfactualMutation(value, label) {
-    const mutation = object(value, label, ["type"], [
-        "paths",
-        "path",
-        "fixture_path",
-        "pointer",
-        "value",
-        "match",
-        "replacement",
-    ]);
-    const type = literal(mutation.type, [
-        "remove_paths",
-        "replace_file",
-        "replace_json_value",
-        "replace_text",
-    ], `${label}.type`);
-    if (type === "remove_paths")
-        return {
-            type,
-            paths: repositoryFiles(mutation.paths, `${label}.paths`),
-        };
-    const target = repositoryFile(mutation.path, `${label}.path`);
-    if (type === "replace_file")
-        return {
-            type,
-            path: target,
-            fixture_path: repositoryFile(mutation.fixture_path, `${label}.fixture_path`),
-        };
-    if (type === "replace_json_value") {
-        const pointer = string(mutation.pointer, `${label}.pointer`);
-        if (!/^\/(?:[^~/]|~[01])+(?:\/(?:[^~/]|~[01])+)*$/u.test(pointer))
-            fail(`${label}.pointer`, "must be a non-root RFC 6901 JSON pointer");
-        if (!Object.hasOwn(mutation, "value"))
-            fail(`${label}.value`, "must be present");
-        assertJsonValue(mutation.value, `${label}.value`);
-        return { type, path: target, pointer, value: mutation.value };
-    }
-    const match = string(mutation.match, `${label}.match`);
-    const replacement = typeof mutation.replacement === "string"
-        ? mutation.replacement
-        : fail(`${label}.replacement`, "must be a string");
-    if (match === replacement)
-        fail(`${label}.replacement`, "must differ from match");
-    return { type, path: target, match, replacement };
-}
-function assertJsonValue(value, label) {
-    if (value === undefined ||
-        typeof value === "function" ||
-        typeof value === "symbol" ||
-        typeof value === "bigint")
-        fail(label, "must be JSON-compatible");
-    try {
-        const encoded = JSON.stringify(value);
-        if (encoded === undefined)
-            fail(label, "must be JSON-compatible");
-        JSON.parse(encoded);
-    }
-    catch {
-        fail(label, "must be JSON-compatible");
-    }
-}
-export function parsePopulation(value, label) {
-    const row = object(value, label, [
-        "check_key",
-        "universe_binding_key",
-        "claims",
-        "observations",
-        "exclusion_rules",
-    ]);
-    const observations = object(row.observations, `${label}.observations`, [
-        "universe_ids",
-        "eligible_ids",
-        "observed_ids",
-        "excluded_items",
-    ]);
-    return {
-        check_key: key(row.check_key, `${label}.check_key`),
-        universe_binding_key: key(row.universe_binding_key, `${label}.universe_binding_key`),
-        claims: strings(row.claims, `${label}.claims`),
-        observations: {
-            universe_ids: string(observations.universe_ids, `${label}.observations.universe_ids`),
-            eligible_ids: string(observations.eligible_ids, `${label}.observations.eligible_ids`),
-            observed_ids: string(observations.observed_ids, `${label}.observations.observed_ids`),
-            excluded_items: string(observations.excluded_items, `${label}.observations.excluded_items`),
-        },
-        exclusion_rules: parseKeyedStatements(row.exclusion_rules, `${label}.exclusion_rules`),
-    };
-}
-export function parseEnvironmentRequirements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const base = object(item, itemLabel, ["key", "kind"], ["target", "host", "port", "timeout_ms"]);
-        const kindValue = literal(base.kind, ["executable", "file", "directory", "env_var", "loopback_tcp"], `${itemLabel}.kind`);
-        const requirementKey = key(base.key, `${itemLabel}.key`);
-        if (kindValue !== "loopback_tcp")
-            return {
-                key: requirementKey,
-                kind: kindValue,
-                target: kindValue === "file" || kindValue === "directory"
-                    ? repositoryFile(base.target, `${itemLabel}.target`)
-                    : string(base.target, `${itemLabel}.target`),
-            };
-        const host = literal(base.host, ["127.0.0.1", "::1", "localhost"], `${itemLabel}.host`);
-        const port = Number(base.port);
-        const timeout = Number(base.timeout_ms);
-        if (!Number.isInteger(port) || port < 1 || port > 65535)
-            fail(`${itemLabel}.port`, "must be an integer from 1 to 65535");
-        if (!Number.isInteger(timeout) || timeout < 10 || timeout > 60_000)
-            fail(`${itemLabel}.timeout_ms`, "must be an integer from 10 to 60000");
-        return {
-            key: requirementKey,
-            kind: kindValue,
-            host,
-            port,
-            timeout_ms: timeout,
-        };
-    });
-}

package/dist/lib/long-task-activation-validation.d.ts

@@ -1,27 +0,0 @@
-import type { AuthoringPreflightDiagnosticV1 } from "./long-task-authoring-preflight-types.js";
-import { type CompiledClaimsV2 } from "./long-task-claims.js";
-import type { CompiledCheckV2, CompiledOutcomeV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import { type ProofAdequacyByCheckV2 } from "./long-task-proof-adequacy.js";
-import { type RiskDecisionV2 } from "./long-task-risk.js";
-import { type AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability.js";
-import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
-export interface ActivationValidationResult {
-    claims: CompiledClaimsV2 | null;
-    risk: RiskDecisionV2 | null;
-    source_hashes: Record<string, string> | null;
-    source_items: CompiledSourceItemV2[] | null;
-    context_snapshot: ContextAuthoritySnapshotV2 | null;
-    project_design_authority: DesignAuthorityIdentityV1 | null;
-    workspace: WorkspaceManifestV2 | null;
-    global_checks: CompiledCheckV2[];
-    outcomes: CompiledOutcomeV2[];
-    proof_adequacy: ProofAdequacyByCheckV2 | null;
-    acceptance_reachability: AcceptanceReachabilityV1 | null;
-}
-export declare function validateContractForActivation(options: {
-    contract: DeliveryContractV2;
-    repository: string;
-    workdir: string;
-    mode: "collect" | "fail_fast";
-    diagnostics?: AuthoringPreflightDiagnosticV1[];
-}): Promise<ActivationValidationResult>;