project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-design-feasibility-binding.js

@@ -1,114 +0,0 @@
-import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, parseDesignResourceFeasibilityDecisionProjections, } from "./design-resource-implementation-feasibility-source-decision.js";
-import { createV1ImplementationFeasibilityTargetModel, createV2ImplementationFeasibilityTargetModel, } from "./design-resource-implementation-feasibility-model.js";
-import { matchingFeasibilityBindingKeys, validateFeasibilityBindingOwnerRoots, } from "./long-task-design-feasibility-binding-owners.js";
-import { validateFeasibilityBlockers, validateSelectedPlannedOwnerClaims, validateTechnicalDecisionClaim, } from "./long-task-design-feasibility-source-closure.js";
-import { invalid } from "./long-task-design-resource-method-binding.js";
-export function validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, options = {}) {
-    const document = preflight.technical_feasibility_documents.find((item) => item.target_ref === contractTarget.target.key);
-    if (!document) {
-        if (!contractTarget.binding.component_binding_refs.length)
-            invalid("componentless_surface_requires_blocker_only_feasibility", contractTarget.target.key);
-        return {
-            attribution_mode: "legacy",
-            consumed_component_binding_refs: [],
-        };
-    }
-    const model = feasibilityTargetModel(preflight, contractTarget.target.key);
-    const decisions = compiledDecisionSources(document, sourceItems);
-    const outcome = contract.outcomes.find((item) => item.key === contractTarget.outcome_key);
-    const bindingsByKey = new Map(outcome.technical.bindings.map((binding) => [binding.key, binding]));
-    const componentBindings = contractTarget.binding.component_binding_refs.map((bindingRef) => {
-        const binding = bindingsByKey.get(bindingRef);
-        if (!binding)
-            invalid("feasibility_component_binding_unknown", `${contractTarget.target.key}:${bindingRef}`);
-        return binding;
-    });
-    const routeBinding = bindingsByKey.get(contractTarget.binding.route_binding_ref);
-    if (!routeBinding)
-        invalid("feasibility_route_binding_unknown", `${contractTarget.target.key}:${contractTarget.binding.route_binding_ref}`);
-    const hasCandidateCells = document.component_family_cells.some((cell) => cell.feasible_realizations.length > 0);
-    const allCellsBlockerOnly = document.component_family_cells.length > 0 &&
-        document.component_family_cells.every((cell) => cell.feasible_realizations.length === 0 && cell.blocker_refs.length > 0);
-    if (!componentBindings.length && hasCandidateCells)
-        invalid("feasibility_component_binding_required", contractTarget.target.key);
-    if (!componentBindings.length && !allCellsBlockerOnly)
-        invalid("componentless_surface_requires_blocker_only_feasibility", contractTarget.target.key);
-    validateFeasibilityBindingOwnerRoots(document, componentBindings, routeBinding);
-    const consumedComponentBindings = new Set();
-    for (const cell of document.component_family_cells) {
-        const blockerOnly = cell.feasible_realizations.length === 0 && cell.blocker_refs.length > 0;
-        if (blockerOnly)
-            continue;
-        const matching = cell.feasible_realizations
-            .map((realization) => ({
-            realization,
-            bindingKeys: matchingFeasibilityBindingKeys(realization, componentBindings),
-        }))
-            .filter((candidate) => candidate.bindingKeys.size > 0);
-        const required = cell.required_realization.realization_ref;
-        if (required !== null &&
-            (matching.length !== 1 || matching[0].realization.key !== required))
-            invalid("feasibility_required_realization_binding_mismatch", `${cell.key}:${required}:${matching.map((item) => item.realization.key).join(",")}`);
-        if (required === null && matching.length === 0)
-            invalid("feasibility_realization_binding_missing", cell.key);
-        if (required === null && matching.length > 1)
-            invalid("feasibility_realization_binding_ambiguous", `${cell.key}:${matching.map((item) => item.realization.key).join(",")}`);
-        const selected = matching.length === 1 ? matching[0] : null;
-        if (selected)
-            for (const bindingKey of selected.bindingKeys)
-                consumedComponentBindings.add(bindingKey);
-        if (required !== null)
-            validateTechnicalDecisionClaim(contract, contractTarget, decisions, cell.required_realization.technical_authority_source_refs, {
-                schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
-                mode: "required_realization",
-                target_ref: cell.target_ref,
-                component_family_ref: cell.component_family_ref,
-                condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, cell.condition_profile_ref),
-                realization_ref: required,
-            }, `required_realization:${cell.key}`);
-        if (selected)
-            validateSelectedPlannedOwnerClaims(contract, contractTarget, document, model, decisions, selected.realization, componentBindings, cell);
-    }
-    if (!options.deferComponentBindingAttribution)
-        validateComponentBindingAttribution(contractTarget, consumedComponentBindings);
-    validateFeasibilityBlockers(contract, contractTarget, document, model, decisions);
-    return {
-        attribution_mode: "feasibility",
-        consumed_component_binding_refs: [...consumedComponentBindings].sort(),
-    };
-}
-function validateComponentBindingAttribution(contractTarget, consumedComponentBindings) {
-    for (const bindingRef of contractTarget.binding.component_binding_refs)
-        if (!consumedComponentBindings.has(bindingRef))
-            invalid("feasibility_component_binding_unattributed", `${contractTarget.target.key}:${bindingRef}`);
-}
-function feasibilityTargetModel(preflight, targetRef) {
-    if ("preflight_schema_version" in preflight) {
-        const target = preflight.handoff.targets.find((candidate) => candidate.key === targetRef);
-        return createV2ImplementationFeasibilityTargetModel(target, preflight.manifest);
-    }
-    const target = preflight.handoff.targets.find((candidate) => candidate.key === targetRef);
-    return createV1ImplementationFeasibilityTargetModel(preflight.handoff, target);
-}
-function compiledDecisionSources(document, sourceItems) {
-    const index = new Map();
-    for (const record of document.source_records) {
-        if (record.locator.kind !== "source_item")
-            continue;
-        const item = sourceItems.find((candidate) => candidate.source_path === record.path &&
-            candidate.key === record.locator.value);
-        if (!item)
-            invalid("feasibility_source_item_not_declared", `${record.key}:${record.path}#${record.locator.value}`);
-        if (item.text_sha256 !== record.locator.text_sha256)
-            invalid("feasibility_source_item_digest_mismatch", `${record.key}:${record.locator.text_sha256}:${item.text_sha256}`);
-        index.set(record.key, {
-            source_record_ref: record.key,
-            source_path: record.path,
-            source_item_key: item.key,
-            source_item_kind: item.kind,
-            text_sha256: item.text_sha256,
-            projections: parseDesignResourceFeasibilityDecisionProjections(record.path, item.key, item.normalized_text),
-        });
-    }
-    return index;
-}

package/dist/lib/long-task-design-feasibility-source-closure.d.ts

@@ -1,11 +0,0 @@
-import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
-import { type DesignResourceFeasibilityDecisionProjection, type DesignResourceFeasibilityDecisionSourceIndex } from "./design-resource-implementation-feasibility-source-decision.js";
-import type { DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
-import type { DeliveryBindingV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
-type FeasibilityCell = DesignResourceImplementationFeasibilityV1["component_family_cells"][number];
-type FeasibleRealization = FeasibilityCell["feasible_realizations"][number];
-export declare function validateSelectedPlannedOwnerClaims(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, decisions: DesignResourceFeasibilityDecisionSourceIndex, realization: FeasibleRealization, bindings: DeliveryBindingV2[], cell: FeasibilityCell): void;
-export declare function validateTechnicalDecisionClaim(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, decisions: DesignResourceFeasibilityDecisionSourceIndex, sourceRefs: string[], expectation: DesignResourceFeasibilityDecisionProjection, label: string): void;
-export declare function validateFeasibilityBlockers(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, decisions: DesignResourceFeasibilityDecisionSourceIndex): void;
-export {};

package/dist/lib/long-task-design-feasibility-source-closure.js

@@ -1,87 +0,0 @@
-import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, requireExactFeasibilityDecisionProjection, } from "./design-resource-implementation-feasibility-source-decision.js";
-import { designFactObligationDescriptors, externalDesignObligationMatches, } from "./long-task-design-obligation.js";
-import { invalid } from "./long-task-design-resource-method-binding.js";
-export function validateSelectedPlannedOwnerClaims(contract, contractTarget, document, model, decisions, realization, bindings, cell) {
-    for (const owner of realization.owner_candidates) {
-        if (owner.kind !== "planned_logical_owner")
-            continue;
-        if (!bindings.some((binding) => binding.existence === "planned" &&
-            (binding.key === owner.locator || binding.target === owner.locator)))
-            continue;
-        validateTechnicalDecisionClaim(contract, contractTarget, decisions, owner.authorization_source_refs, {
-            schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
-            mode: "planned_owner_authorization",
-            target_ref: cell.target_ref,
-            component_family_ref: cell.component_family_ref,
-            condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, cell.condition_profile_ref),
-            owner_locator: owner.locator,
-        }, `planned_owner:${cell.key}:${owner.locator}`);
-    }
-}
-export function validateTechnicalDecisionClaim(contract, contractTarget, decisions, sourceRefs, expectation, label) {
-    const source = requireDecisionSource(sourceRefs, decisions, expectation, label, ["technical_obligation"], true);
-    const claim = exactSourceClaim(contract, source, label);
-    const validOutcomeClaim = claim.disposition.type === "claim" &&
-        claim.disposition.refs.some((ref) => ref.startsWith(`${contractTarget.outcome_key}.`));
-    if (!validOutcomeClaim && claim.disposition.type !== "global_constraint")
-        invalid("feasibility_technical_decision_claim_disposition_invalid", `${label}:${claim.key}:${claim.disposition.type}`);
-}
-export function validateFeasibilityBlockers(contract, contractTarget, document, model, decisions) {
-    for (const blocker of document.blockers) {
-        const source = requireDecisionSource(blocker.source_record_refs, decisions, {
-            schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
-            mode: "feasibility_blocker",
-            target_ref: blocker.target_ref,
-            component_family_ref: blocker.component_family_ref,
-            condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, blocker.condition_profile_ref),
-            blocker_ref: blocker.key,
-            substrate_observation_refs: blocker.substrate_observation_refs,
-        }, `blocker:${blocker.key}`, ["decision", "external_confirmation"], false);
-        const claim = exactSourceClaim(contract, source, `blocker:${blocker.key}`);
-        if (source.source_item_kind === "decision") {
-            if (claim.disposition.type !== "decision_required")
-                invalid("feasibility_blocker_decision_required", `${blocker.key}:${claim.key}:${claim.disposition.type}`);
-            continue;
-        }
-        if (claim.disposition.type !== "external_confirmation")
-            invalid("feasibility_blocker_external_confirmation_required", `${blocker.key}:${claim.key}:${claim.disposition.type}`);
-        const impactedTargetClaims = new Set(contractTarget.target.claim_refs.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`));
-        const exactTargetDesignObligations = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.outcome_key === contractTarget.outcome_key &&
-            descriptor.target_key === contractTarget.target.key);
-        for (const confirmationRef of claim.disposition.refs) {
-            const confirmation = contract.global.acceptance.external_confirmations.find((candidate) => candidate.key === confirmationRef);
-            if (!confirmation)
-                invalid("feasibility_blocker_confirmation_unknown", `${blocker.key}:${confirmationRef}`);
-            if (!confirmation.blocks_target)
-                invalid("feasibility_blocker_confirmation_not_blocking", `${blocker.key}:${confirmationRef}`);
-            if (!confirmation.obligations?.some((obligation) => obligation.result_kind === "actual" &&
-                obligation.fact_ref !== null &&
-                obligation.proof_ref !== null))
-                invalid("feasibility_blocker_confirmation_exact_fact_required", `${blocker.key}:${confirmationRef}`);
-        }
-        if (!contract.global.acceptance.external_confirmations.some((confirmation) => confirmation.blocks_target &&
-            confirmation.impact_claims.some((claimRef) => impactedTargetClaims.has(claimRef)) &&
-            confirmation.obligations?.some((obligation) => exactTargetDesignObligations.some((descriptor) => externalDesignObligationMatches(obligation, descriptor)))))
-            invalid("feasibility_blocker_confirmation_target_claim_missing", `${blocker.key}:${contractTarget.target.key}`);
-    }
-}
-function requireDecisionSource(sourceRefs, decisions, expectation, label, allowedItemKinds, allReferencesMustBeSourceItems) {
-    try {
-        return requireExactFeasibilityDecisionProjection(sourceRefs, decisions, expectation, label, { allReferencesMustBeSourceItems, allowedItemKinds });
-    }
-    catch (error) {
-        invalid("feasibility_source_decision_invalid", `${label}:${message(error)}`);
-    }
-}
-function exactSourceClaim(contract, source, label) {
-    if (!contract.task.source_paths.includes(source.source_path))
-        invalid("feasibility_authority_source_not_declared", `${label}:${source.source_path}`);
-    const sourceRef = `${source.source_path}#${source.source_item_key}`;
-    const matching = contract.source_claims.filter((claim) => claim.source_ref === sourceRef);
-    if (matching.length !== 1)
-        invalid("feasibility_authority_claim_count", `${label}:${sourceRef}:${matching.length}`);
-    return matching[0];
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-design-obligation.d.ts

@@ -1,50 +0,0 @@
-import type { DeliveryCheckV2, DeliveryContractV2, DeliveryDesignFactExpectationV2, EvidenceCapabilityV2, ExternalConfirmationV2, ProofSurface } from "./long-task-delivery-types.js";
-type DesignObligationContract = {
-    outcomes: ReadonlyArray<{
-        key: string;
-        product: Pick<DeliveryContractV2["outcomes"][number]["product"], "surface_bindings">;
-        acceptance: {
-            checks: ReadonlyArray<Pick<DeliveryCheckV2, "key" | "proof_surface" | "positive_assertions" | "negative_assertions">>;
-        };
-    }>;
-};
-export interface DesignFactObligationDescriptorV1 {
-    source_obligation_ref: string;
-    outcome_key: string;
-    check_key: string;
-    target_key: string;
-    assertion_ref: string;
-    local_claim_ref: string;
-    claim_ref: string;
-    applicability_ref: string;
-    fact_ref: string;
-    method: string;
-    proof_surface: ProofSurface;
-    evidence_capabilities: EvidenceCapabilityV2[];
-    expected_authority_ref: string;
-    expected: DeliveryDesignFactExpectationV2["expected"];
-    comparison: DeliveryDesignFactExpectationV2["comparison"];
-    observation_sensitivity: "plain" | "protected";
-}
-export declare function designGroundObligationRef(targetKey: string, method: string, conditionKey: string, factRef: string): string;
-export declare function designFactObligationDescriptors(contract: DesignObligationContract): DesignFactObligationDescriptorV1[];
-export declare function exactExternalDesignObligationRefs(contract: DesignObligationContract & {
-    global: {
-        acceptance: {
-            external_confirmations: readonly ExternalConfirmationV2[];
-        };
-    };
-}, outcomeKey: string, checkKey: string): Set<string>;
-export declare function externalDesignObligationMatches(obligation: NonNullable<ExternalConfirmationV2["obligations"]>[number], descriptor: DesignFactObligationDescriptorV1): boolean;
-export declare function findDesignFactObligation(contract: DesignObligationContract, identity: {
-    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?: readonly EvidenceCapabilityV2[];
-    evidence_capabilities?: readonly EvidenceCapabilityV2[];
-}): DesignFactObligationDescriptorV1 | null;
-export {};

package/dist/lib/long-task-design-obligation.js

@@ -1,99 +0,0 @@
-export function designGroundObligationRef(targetKey, method, conditionKey, factRef) {
-    return `design.${targetKey}.${method}.${conditionKey}.${factRef}`;
-}
-export function designFactObligationDescriptors(contract) {
-    const result = [];
-    for (const outcome of contract.outcomes)
-        for (const surface of outcome.product.surface_bindings ?? [])
-            for (const target of surface.design_targets) {
-                const check = outcome.acceptance.checks.find((candidate) => candidate.key === target.conformance_check_ref);
-                if (!check)
-                    continue;
-                for (const binding of target.verification_method_bindings)
-                    for (const artifact of binding.evidence_artifacts)
-                        for (const expectation of artifact.fact_expectations) {
-                            const descriptor = descriptorForExpectation(outcome.key, check, target.key, binding.assertion_ref, designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref), expectation.fact_ref, binding.method, expectation);
-                            if (descriptor)
-                                result.push(descriptor);
-                        }
-                for (const binding of target.symbolic_method_bindings ?? [])
-                    for (const expectation of binding.rule_expectations) {
-                        const descriptor = descriptorForExpectation(outcome.key, check, target.key, binding.assertion_ref, expectation.obligation_ref, expectation.fact_rule_ref, binding.method, expectation);
-                        if (descriptor)
-                            result.push(descriptor);
-                    }
-            }
-    return result;
-}
-export function exactExternalDesignObligationRefs(contract, outcomeKey, checkKey) {
-    const confirmations = contract.global.acceptance.external_confirmations;
-    return new Set(designFactObligationDescriptors(contract)
-        .filter((descriptor) => descriptor.outcome_key === outcomeKey &&
-        descriptor.check_key === checkKey &&
-        confirmations.some((confirmation) => confirmation.blocks_target &&
-            confirmation.obligations?.some((obligation) => externalDesignObligationMatches(obligation, descriptor))))
-        .map((descriptor) => descriptor.source_obligation_ref));
-}
-export function externalDesignObligationMatches(obligation, descriptor) {
-    return (obligation.claim_ref === descriptor.claim_ref &&
-        obligation.applicability_ref === descriptor.applicability_ref &&
-        obligation.fact_ref === descriptor.fact_ref &&
-        obligation.proof_ref === descriptor.source_obligation_ref &&
-        obligation.method === descriptor.method &&
-        obligation.proof_surface === descriptor.proof_surface &&
-        sameSet(obligation.evidence_capabilities, descriptor.evidence_capabilities) &&
-        obligation.expected_authority_ref === descriptor.expected_authority_ref &&
-        obligation.result_kind === "actual" &&
-        obligation.judgment_basis === undefined);
-}
-export function findDesignFactObligation(contract, identity) {
-    if (!identity.outcome_key || !identity.fact_ref || !identity.proof_ref)
-        return null;
-    const capabilities = identity.evidence_capabilities ??
-        identity.required_evidence_capabilities ??
-        [];
-    const candidates = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.source_obligation_ref === identity.proof_ref &&
-        descriptor.outcome_key === identity.outcome_key &&
-        descriptor.claim_ref === identity.claim_ref &&
-        descriptor.applicability_ref === identity.applicability_ref &&
-        descriptor.fact_ref === identity.fact_ref &&
-        descriptor.method === identity.method &&
-        descriptor.proof_surface === identity.proof_surface &&
-        sameSet(descriptor.evidence_capabilities, capabilities));
-    return candidates.length === 1 ? candidates[0] : null;
-}
-function descriptorForExpectation(outcomeKey, check, targetKey, assertionRef, sourceObligationRef, factRef, method, expectation) {
-    const assertion = findAssertion(check, assertionRef);
-    if (!assertion ||
-        assertion.claims.length !== 1 ||
-        !assertion.applicability_ref)
-        return null;
-    const localClaimRef = assertion.claims[0];
-    return {
-        source_obligation_ref: sourceObligationRef,
-        outcome_key: outcomeKey,
-        check_key: check.key,
-        target_key: targetKey,
-        assertion_ref: assertionRef,
-        local_claim_ref: localClaimRef,
-        claim_ref: `${outcomeKey}.${localClaimRef}`,
-        applicability_ref: assertion.applicability_ref,
-        fact_ref: factRef,
-        method,
-        proof_surface: check.proof_surface,
-        evidence_capabilities: [...assertion.evidence_capabilities].sort(),
-        expected_authority_ref: `design-proof:${sourceObligationRef}`,
-        expected: expectation.expected,
-        comparison: expectation.comparison,
-        observation_sensitivity: expectation.observation_sensitivity,
-    };
-}
-function findAssertion(check, assertionRef) {
-    return ([...check.positive_assertions, ...check.negative_assertions].find((assertion) => assertion.key === assertionRef) ?? null);
-}
-function sameSet(left, right) {
-    return (left.length === right.length &&
-        new Set(left).size === left.length &&
-        new Set(right).size === right.length &&
-        left.every((value) => right.includes(value)));
-}

package/dist/lib/long-task-design-resource-handoff.d.ts

@@ -1,20 +0,0 @@
-import type { DesignResourceHandoffPreflightV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
-import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
-import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export interface ContractDesignTarget {
-    outcome_key: string;
-    binding: DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number];
-    target: DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number]["design_targets"][number];
-}
-export interface IndexedHandoffTarget {
-    preflight: DesignResourceHandoffPreflightV1;
-    target: DesignResourceHandoffTargetV1;
-}
-export interface LongTaskDesignHandoffConsumer {
-    consume(preflight: DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2): void;
-    finish(): void;
-}
-export type LongTaskDesignHandoffPreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
-export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[]): Promise<LongTaskDesignHandoffPreflight[]>;
-export declare function validateProjectDesignAuthoritySet(preflights: LongTaskDesignHandoffPreflight[]): void;
-export declare function createLongTaskDesignHandoffConsumer(contract: DeliveryContractV2, sourceItems?: CompiledSourceItemV2[]): LongTaskDesignHandoffConsumer;

package/dist/lib/long-task-design-resource-handoff.js

@@ -1,265 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
-import { createDesignResourceHandoffSetIntegrity } from "./design-resource-handoff-set-integrity.js";
-import { preflightParsedDesignResourceHandoffAny } from "./design-resource-handoff-validation.js";
-import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateSymbolicTargetIdentity, validateSymbolicVerificationMethodBindings, validateVerificationMethodBindings, } from "./long-task-design-resource-method-binding.js";
-import { validateLongTaskDesignTargetCapabilities } from "./long-task-design-target-capabilities.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { validateLongTaskDesignFeasibilityBindings } from "./long-task-design-feasibility-binding.js";
-export async function validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems) {
-    const consumer = createLongTaskDesignHandoffConsumer(contract, sourceItems);
-    const preflights = [];
-    for (const sourcePath of contract.task.source_paths) {
-        if (!sourcePath.toLowerCase().endsWith(".md"))
-            continue;
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourcePath.split("/")), `design_resource_handoff_source:${sourcePath}`);
-        const content = await readFile(file, "utf8");
-        if (!containsDesignResourceHandoff(content))
-            continue;
-        const preflight = await preflightParsedDesignResourceHandoffAny(repository, parseDesignResourceHandoffMarkdown(sourcePath, content));
-        preflights.push(preflight);
-        consumer.consume(preflight);
-    }
-    validateProjectDesignAuthoritySet(preflights);
-    consumer.finish();
-    return preflights;
-}
-export function validateProjectDesignAuthoritySet(preflights) {
-    let expected = null;
-    for (const preflight of preflights) {
-        const identity = preflight.project_design_authority_resolution.identity;
-        if (!identity)
-            continue;
-        const canonical = JSON.stringify(identity);
-        if (expected === null)
-            expected = canonical;
-        else if (expected !== canonical)
-            invalid("project_design_authority_identity_conflict", `${JSON.parse(expected).closure_digest}:${identity.closure_digest}`);
-    }
-}
-export function createLongTaskDesignHandoffConsumer(contract, sourceItems = []) {
-    const contractTargets = contract.outcomes.flatMap((outcome) => outcome.product.surface_bindings.flatMap((binding) => binding.design_targets.map((target) => ({
-        outcome_key: outcome.key,
-        binding,
-        target,
-    }))));
-    const contractTargetsByKey = new Map(contractTargets.map((item) => [item.target.key, item]));
-    const indexedTargetKeys = new Set();
-    const consumed = new Set();
-    const validationErrors = new Map();
-    const feasibilityBindingAttributionBySurface = new Map();
-    let duplicate = null;
-    const unbound = [];
-    const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
-    const allSourceItems = new Set();
-    const resourcePaths = new Map();
-    let crossVersionIssue = null;
-    const recordCrossVersionIssue = (code, detail) => {
-        crossVersionIssue ??= { code, detail };
-    };
-    return {
-        consume(preflight) {
-            for (const sourceItem of preflight.source_item_keys) {
-                if (allSourceItems.has(sourceItem))
-                    recordCrossVersionIssue("handoff_set_source_item_duplicate", sourceItem);
-                else
-                    allSourceItems.add(sourceItem);
-            }
-            for (const resource of preflight.handoff.resources) {
-                const identity = JSON.stringify(resource);
-                const previous = resourcePaths.get(resource.path);
-                if (previous && previous !== identity)
-                    recordCrossVersionIssue("handoff_set_resource_path_conflict", resource.path);
-                else
-                    resourcePaths.set(resource.path, identity);
-            }
-            for (const input of preflight.handoff.technical_feasibility_inputs) {
-                const identity = JSON.stringify(input);
-                const previous = resourcePaths.get(input.path);
-                if (previous && previous !== identity)
-                    recordCrossVersionIssue("handoff_set_feasibility_path_conflict", input.path);
-                else
-                    resourcePaths.set(input.path, identity);
-            }
-            if (!("preflight_schema_version" in preflight))
-                handoffSetIntegrity.consume(preflight);
-            for (const target of preflight.handoff.targets) {
-                if (indexedTargetKeys.has(target.key)) {
-                    duplicate ??= target.key;
-                    continue;
-                }
-                indexedTargetKeys.add(target.key);
-                const contractTarget = contractTargetsByKey.get(target.key);
-                if (!contractTarget) {
-                    unbound.push(target.key);
-                    continue;
-                }
-                consumed.add(target.key);
-                try {
-                    if ("preflight_schema_version" in preflight) {
-                        const indexedTarget = {
-                            preflight,
-                            target,
-                        };
-                        validateSymbolicTargetIdentity(contractTarget, indexedTarget);
-                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
-                        validateSymbolicCoverageClaims(contract, contractTarget, indexedTarget);
-                        validateBlockerBindings(contract, contractTarget, indexedTarget);
-                    }
-                    else {
-                        const indexedTarget = {
-                            preflight,
-                            target: target,
-                        };
-                        validateTargetIdentity(contractTarget, indexedTarget);
-                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
-                        validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
-                        validateCoverageClaims(contract, contractTarget, indexedTarget);
-                        validateBlockerBindings(contract, contractTarget, indexedTarget);
-                    }
-                }
-                catch (error) {
-                    validationErrors.set(target.key, error);
-                }
-            }
-        },
-        finish() {
-            if (duplicate)
-                invalid("handoff_target_duplicate", duplicate);
-            handoffSetIntegrity.finish();
-            if (crossVersionIssue)
-                invalid(crossVersionIssue.code, crossVersionIssue.detail);
-            for (const contractTarget of contractTargets) {
-                if (!consumed.has(contractTarget.target.key))
-                    invalid("target_handoff_missing", contractTarget.target.key);
-                if (validationErrors.has(contractTarget.target.key))
-                    throw validationErrors.get(contractTarget.target.key);
-            }
-            validateSurfaceFeasibilityBindingAttribution(contractTargets, feasibilityBindingAttributionBySurface);
-            if (unbound.length)
-                invalid("handoff_target_unbound", unbound[0]);
-        },
-    };
-}
-function recordFeasibilityBindingAttribution(bySurface, contractTarget, result) {
-    const key = surfaceBindingIdentity(contractTarget);
-    const attribution = bySurface.get(key) ?? {
-        modes: new Set(),
-        consumed_component_binding_refs: new Set(),
-    };
-    attribution.modes.add(result.attribution_mode);
-    for (const bindingRef of result.consumed_component_binding_refs)
-        attribution.consumed_component_binding_refs.add(bindingRef);
-    bySurface.set(key, attribution);
-}
-function validateSurfaceFeasibilityBindingAttribution(contractTargets, bySurface) {
-    const surfaces = new Map();
-    for (const contractTarget of contractTargets)
-        surfaces.set(surfaceBindingIdentity(contractTarget), contractTarget);
-    for (const [surfaceKey, contractTarget] of surfaces) {
-        const attribution = bySurface.get(surfaceKey);
-        if (!attribution?.modes.has("feasibility"))
-            continue;
-        for (const bindingRef of contractTarget.binding.component_binding_refs)
-            if (!attribution.consumed_component_binding_refs.has(bindingRef))
-                invalid("feasibility_component_binding_unattributed", `${contractTarget.binding.key}:${bindingRef}`);
-    }
-}
-function surfaceBindingIdentity(contractTarget) {
-    return `${contractTarget.outcome_key}\0${contractTarget.binding.key}`;
-}
-function validateSymbolicCoverageClaims(contract, contractTarget, indexed) {
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const rows = indexed.preflight.handoff.coverage.filter((row) => row.target_ref === contractTarget.target.key);
-    if (!rows.length)
-        invalid("v2_target_covered_claims_required", contractTarget.target.key);
-    const sourceItemRefs = [
-        ...new Set([
-            ...rows.flatMap((row) => row.source_item_refs),
-            ...indexed.preflight.manifest.fact_rules.flatMap((rule) => rule.source_item_refs),
-            ...indexed.preflight.manifest.disposition_regions.flatMap((region) => region.source_item_refs),
-        ]),
-    ];
-    const claimsBySourceItem = new Map();
-    for (const sourceItemRef of sourceItemRefs)
-        claimsBySourceItem.set(sourceItemRef, designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims));
-    validateSymbolicVerificationMethodBindings(contract, contractTarget, indexed, claimsBySourceItem);
-}
-function validateCoverageClaims(contract, contractTarget, indexed) {
-    const target = contractTarget.target;
-    const check = contract.outcomes
-        .find((item) => item.key === contractTarget.outcome_key)
-        .acceptance.checks.find((item) => item.key === target.conformance_check_ref);
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const rows = indexed.preflight.handoff.coverage.filter((row) => row.disposition === "covered" && row.target_refs.includes(target.key));
-    if (!rows.length)
-        invalid("target_covered_claims_required", target.key);
-    const facts = indexed.preflight.handoff.facts.filter((fact) => fact.target_ref === target.key);
-    const factRefs = new Set(facts.map((fact) => fact.key));
-    const proofs = indexed.preflight.handoff.proof_obligations.filter((proof) => factRefs.has(proof.fact_ref));
-    if (!facts.length)
-        invalid("target_facts_required", target.key);
-    const claimsBySourceItem = new Map();
-    for (const row of rows)
-        for (const sourceItemRef of row.source_item_refs) {
-            const localClaims = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
-            claimsBySourceItem.set(sourceItemRef, localClaims);
-        }
-    validateVerificationMethodBindings(target, check, facts, proofs, indexed, claimsBySourceItem);
-}
-function validateBlockerBindings(contract, contractTarget, indexed) {
-    const bound = new Map(contractTarget.binding.acceptance_blockers.map((item) => [item.key, item]));
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const confirmations = new Map(contract.global.acceptance.external_confirmations.map((item) => [
-        item.key,
-        item,
-    ]));
-    const availableMethods = new Set([
-        ...contractTarget.target.verification_method_bindings,
-        ...(contractTarget.target.symbolic_method_bindings ?? []),
-    ].map((item) => item.method));
-    const blockers = "preflight_schema_version" in indexed.preflight
-        ? indexed.preflight.manifest.acceptance_blockers
-        : indexed.preflight.handoff.acceptance_blockers;
-    for (const blocker of blockers) {
-        if (!blocker.target_refs.includes(contractTarget.target.key))
-            continue;
-        const contractBlocker = bound.get(blocker.key);
-        if (!contractBlocker)
-            invalid("acceptance_blocker_unbound", `${contractTarget.target.key}:${blocker.key}`);
-        assertSameSet(contractBlocker.source_item_refs, blocker.source_item_refs, "acceptance_blocker_source_items_mismatch", blocker.key);
-        assertSameSet(contractBlocker.verification_methods, blocker.verification_methods, "acceptance_blocker_methods_mismatch", blocker.key);
-        assertSameSet(contractBlocker.required_capabilities, blocker.required_capabilities, "acceptance_blocker_capabilities_mismatch", blocker.key);
-        for (const method of blocker.verification_methods)
-            if (!availableMethods.has(method))
-                invalid("acceptance_blocker_method_unbound", `${blocker.key}:${method}`);
-        const fullClaimRefs = blocker.source_item_refs.flatMap((sourceItemRef) => {
-            const local = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
-            return local.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`);
-        });
-        if (contractBlocker.status === "machine_claim") {
-            const executionTarget = contract.task.execution_targets.find((item) => item.key === contractTarget.binding.target_ref);
-            if (!executionTarget)
-                invalid("execution_target_unknown", `${contractTarget.target.key}:${contractTarget.binding.target_ref}`);
-            for (const capability of blocker.required_capabilities)
-                if (!executionTarget.capabilities.includes(capability))
-                    invalid("acceptance_blocker_target_capability_missing", `${blocker.key}:${executionTarget.key}:${capability}`);
-            const expectedLocal = fullClaimRefs.map((claimRef) => claimRef.slice(contractTarget.outcome_key.length + 1));
-            for (const claimRef of expectedLocal)
-                if (!contractBlocker.refs.includes(claimRef))
-                    invalid("acceptance_blocker_machine_claim_lineage_missing", `${blocker.key}:${claimRef}`);
-        }
-        else
-            for (const confirmationRef of contractBlocker.refs) {
-                const confirmation = confirmations.get(confirmationRef);
-                if (!confirmation)
-                    invalid("acceptance_blocker_confirmation_unknown", `${blocker.key}:${confirmationRef}`);
-                for (const claimRef of fullClaimRefs)
-                    if (!confirmation.impact_claims.includes(claimRef))
-                        invalid("acceptance_blocker_confirmation_lineage_missing", `${blocker.key}:${confirmationRef}:${claimRef}`);
-            }
-    }
-}