project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-delivery-validation.js

@@ -1,252 +0,0 @@
-import { assertCompiledClaimsCovered, compileProductClaimCoverage, } from "./long-task-claims.js";
-import { fail } from "./long-task-delivery-shape.js";
-import { proveRepositoryPatternSubset } from "./long-task-paths.js";
-import { validateSourceClaimMappings } from "./long-task-source-claim-validation.js";
-import { validateDeclaredCheckSafety } from "./long-task-claim-proof-policy.js";
-import { validateEvidenceAdapterCompatibility } from "./long-task-evidence-adapter-policy.js";
-import { validateEvidenceCapabilityDeclarations } from "./long-task-evidence-capability-policy.js";
-import { validateDeliveryStages } from "./long-task-stage-policy.js";
-import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "./long-task-target-policy.js";
-import { validateUiSurfaceBindings } from "./long-task-ui-surface-policy.js";
-import { controlFieldFacts } from "./long-task-control-fields.js";
-import { validateSemanticAssuranceShape } from "./long-task-semantic-assurance-policy.js";
-export function validateDeliveryContractStructure(contract, options = {}) {
-    validateUniqueKeys(contract);
-    validateDependencies(contract);
-    validateControlClosure(contract);
-    validateOwnerAndBindings(contract);
-    validateDeclaredCheckSafety(contract);
-    validateEvidenceAdapters(contract);
-    const claims = compileProductClaimCoverage(contract, {
-        allow_uncovered: true,
-    });
-    validateSourceClaimMappings(contract, claims);
-    validateUiSurfaceBindings(contract, claims, undefined, options);
-    assertCompiledClaimsCovered(claims);
-    validateDeliveryStages(contract);
-    validateExecutionTargets(contract);
-    validateSemanticAssuranceShape(contract);
-    validateEvidenceCapabilityDeclarations(contract);
-    validateExternalConfirmationImpacts(contract, claims);
-}
-export function deliveryContractStructureDiagnostics(contract, options = {}) {
-    const diagnostics = [];
-    const report = (message) => diagnostics.push(message);
-    validateUniqueKeys(contract, report);
-    validateDependencies(contract, report);
-    validateControlClosure(contract, report);
-    validateDeliveryStages(contract, report);
-    validateExecutionTargets(contract, report);
-    validateSemanticAssuranceShape(contract, report);
-    validateEvidenceCapabilityDeclarations(contract, report);
-    validateOwnerAndBindings(contract, report);
-    validateDeclaredCheckSafety(contract, report);
-    validateEvidenceAdapters(contract, report);
-    let claims = null;
-    capture(diagnostics, () => {
-        claims = compileProductClaimCoverage(contract, { allow_uncovered: true });
-    });
-    if (claims) {
-        validateSourceClaimMappings(contract, claims, report);
-        validateUiSurfaceBindings(contract, claims, report, options);
-        validateExternalConfirmationImpacts(contract, claims, report);
-        capture(diagnostics, () => assertCompiledClaimsCovered(claims));
-    }
-    return [...new Set(diagnostics)];
-}
-function validateEvidenceAdapters(contract, report) {
-    for (const check of contract.global.acceptance.checks)
-        captureOrReport(report, () => validateEvidenceAdapterCompatibility(check, null));
-    for (const outcome of contract.outcomes)
-        for (const check of outcome.acceptance.checks)
-            captureOrReport(report, () => validateEvidenceAdapterCompatibility(check, outcome.key));
-}
-function validateUniqueKeys(contract, report) {
-    unique(contract.outcomes.map((outcome) => outcome.key), "outcome_key_duplicate", report);
-    unique(contract.global.acceptance.checks.map((check) => check.key), "global_check_key_duplicate", report);
-    unique(contract.source_claims.map((claim) => claim.key), "source_claim_key_duplicate", report);
-    for (const [fact, outcomes] of Object.entries(contract.risk.facts))
-        unique(outcomes, `risk_fact_outcome_duplicate:${fact}`, report);
-    unique(contract.global.acceptance.counterfactual_controls.map((control) => control.key), "global_counterfactual_key_duplicate", report);
-    unique(contract.global.acceptance.external_confirmations.map((item) => item.key), "external_confirmation_key_duplicate", report);
-    unique([
-        ...contract.global.product.non_goals,
-        ...contract.global.technical.constraints,
-        ...contract.global.technical.forbidden_paths,
-        ...contract.global.technical.forbidden_shortcuts,
-    ].map((item) => item.key), "global_constraint_key_duplicate", report);
-    for (const outcome of contract.outcomes) {
-        if (outcome.semantic_fact_bindings.manifest_ref !==
-            contract.semantic_fact_manifest.key)
-            issue(report, "semantic_fact_manifest_ref_mismatch", outcome.key);
-        if (!outcome.semantic_fact_bindings.facts.length)
-            issue(report, "semantic_fact_binding_required", outcome.key);
-        if (!outcome.semantic_fact_bindings.proofs.length)
-            issue(report, "semantic_fact_proof_binding_required", outcome.key);
-        unique(outcome.semantic_fact_bindings.facts.map((item) => item.fact_ref), `semantic_fact_ref_duplicate:${outcome.key}`, report);
-        unique(outcome.semantic_fact_bindings.facts.map((item) => item.claim_ref), `semantic_fact_claim_duplicate:${outcome.key}`, report);
-        unique(outcome.semantic_fact_bindings.proofs.map((item) => item.proof_ref), `semantic_fact_proof_duplicate:${outcome.key}`, report);
-        const semanticFacts = new Set(outcome.semantic_fact_bindings.facts.map((item) => item.fact_ref));
-        for (const proof of outcome.semantic_fact_bindings.proofs)
-            if (!semanticFacts.has(proof.fact_ref))
-                issue(report, "semantic_fact_proof_fact_unknown", `${outcome.key}:${proof.proof_ref}:${proof.fact_ref}`);
-        for (const fact of semanticFacts)
-            if (!outcome.semantic_fact_bindings.proofs.some((proof) => proof.fact_ref === fact))
-                issue(report, "semantic_fact_proof_required", `${outcome.key}:${fact}`);
-        unique(outcome.acceptance.checks.map((check) => check.key), `check_key_duplicate:${outcome.key}`, report);
-        unique(outcome.product.requirements.map((item) => item.key), `requirement_key_duplicate:${outcome.key}`, report);
-        unique(outcome.product.controls.map((control) => control.key), `control_key_duplicate:${outcome.key}`, report);
-        unique(outcome.product.control_relations.map((relation) => relation.key), `control_relation_key_duplicate:${outcome.key}`, report);
-        unique(outcome.product.non_completing_outcomes.map((item) => item.key), `non_completing_key_duplicate:${outcome.key}`, report);
-        unique(outcome.technical.obligations.map((item) => item.key), `obligation_key_duplicate:${outcome.key}`, report);
-        unique(outcome.technical.forbidden_shortcuts.map((item) => item.key), `forbidden_shortcut_key_duplicate:${outcome.key}`, report);
-        unique(outcome.technical.bindings.map((item) => item.key), `binding_key_duplicate:${outcome.key}`, report);
-        unique(outcome.acceptance.counterfactual_controls.map((item) => item.key), `counterfactual_key_duplicate:${outcome.key}`, report);
-        for (const check of outcome.acceptance.checks) {
-            unique(check.environment_requirements.map((item) => item.key), `environment_requirement_key_duplicate:${outcome.key}:${check.key}`, report);
-            unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key), `assertion_key_duplicate:${outcome.key}:${check.key}`, report);
-            unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.observation), `assertion_observation_duplicate:${outcome.key}:${check.key}`, report);
-        }
-    }
-    for (const check of contract.global.acceptance.checks)
-        unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.observation), `assertion_observation_duplicate:GLOBAL:${check.key}`, report);
-}
-function validateControlClosure(contract, report) {
-    for (const outcome of contract.outcomes) {
-        const controls = new Set(outcome.product.controls.map((control) => control.key));
-        const closure = outcome.product.control_relation_closure;
-        const relations = outcome.product.control_relations;
-        if (closure.state === "unresolved")
-            issue(report, "control_relation_closure_unresolved", outcome.key);
-        if (closure.state === "specified" && !relations.length)
-            issue(report, "control_relation_required", outcome.key);
-        if (closure.state === "not_applicable" && relations.length)
-            issue(report, "control_relation_forbidden_when_not_applicable", outcome.key);
-        if (!controls.size && closure.state !== "not_applicable")
-            issue(report, "control_relation_closure_without_controls", outcome.key);
-        for (const control of outcome.product.controls) {
-            const facts = controlFieldFacts(control);
-            const unresolved = facts
-                .filter((fact) => fact.state === "unresolved")
-                .map((fact) => fact.contract_field);
-            if (unresolved.length)
-                issue(report, "control_field_unresolved", `${outcome.key}:${control.key}:${unresolved.join(",")}`);
-            if (!facts.some((fact) => [
-                "navigation_result",
-                "interaction",
-                "trigger",
-                "location",
-            ].includes(fact.contract_field) && fact.state === "specified"))
-                issue(report, "control_root_behavior_required", `${outcome.key}:${control.key}`);
-        }
-        for (const relation of relations) {
-            if (relation.control_refs.length < 2)
-                issue(report, "control_relation_control_refs_required", `${outcome.key}:${relation.key}`);
-            if (new Set(relation.control_refs).size !== relation.control_refs.length)
-                issue(report, "control_relation_control_ref_duplicate", `${outcome.key}:${relation.key}`);
-            for (const reference of relation.control_refs)
-                if (!controls.has(reference))
-                    issue(report, "control_relation_control_ref_unknown", `${outcome.key}:${relation.key}:${reference}`);
-        }
-    }
-}
-function validateOwnerAndBindings(contract, report) {
-    const contextRefs = new Set(contract.task.context_refs);
-    for (const outcome of contract.outcomes) {
-        for (const reference of outcome.product.owner.context_refs)
-            if (!contextRefs.has(reference))
-                issue(report, "owner_context_ref_unknown", `${outcome.key}:${reference}`);
-        if (!outcome.product.owner.path_globs.length)
-            issue(report, "owner_path_globs_empty", outcome.key);
-        for (const candidate of [
-            ...outcome.technical.expected_change_paths,
-            ...outcome.technical.allowed_support_paths,
-        ])
-            if (!outcome.product.owner.path_globs.some((owner) => isProvenSubset(candidate, owner)))
-                issue(report, "path_outside_owner_boundary", `${outcome.key}:${candidate}`);
-        const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
-        for (const binding of outcome.technical.bindings) {
-            for (const carrier of binding.carrier_paths)
-                if (!outcome.product.owner.path_globs.some((owner) => isProvenSubset(carrier, owner)))
-                    issue(report, "binding_carrier_outside_owner_boundary", `${outcome.key}:${binding.key}:${carrier}`);
-            if (binding.kind === "verified") {
-                const check = checks.get(binding.verification_check_key ?? "");
-                if (!check) {
-                    issue(report, "verified_binding_check_unknown", `${outcome.key}:${binding.key}`);
-                    continue;
-                }
-                const obligationClaim = `obligation.${binding.key}`;
-                const covered = [
-                    ...check.positive_assertions,
-                    ...check.negative_assertions,
-                ].some((assertion) => assertion.claims.includes(obligationClaim));
-                if (!covered)
-                    issue(report, "verified_binding_obligation_uncovered", `${outcome.key}:${binding.key}`);
-            }
-        }
-    }
-}
-function isProvenSubset(candidate, owner) {
-    return (proveRepositoryPatternSubset(candidate, owner).status === "proven_subset");
-}
-function unique(values, code, report) {
-    const seen = new Set();
-    for (const value of values) {
-        if (seen.has(value))
-            issue(report, code, value);
-        seen.add(value);
-    }
-}
-function capture(diagnostics, action) {
-    try {
-        action();
-    }
-    catch (error) {
-        diagnostics.push(error instanceof Error ? error.message : String(error));
-    }
-}
-function validateDependencies(contract, report) {
-    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
-    for (const outcome of contract.outcomes)
-        for (const dependency of outcome.depends_on) {
-            if (dependency === outcome.key)
-                issue(report, "outcome_dependency_self", outcome.key);
-            if (!outcomes.has(dependency))
-                issue(report, "outcome_dependency_unknown", `${outcome.key}:${dependency}`);
-        }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (value) => {
-        if (visiting.has(value)) {
-            issue(report, "outcome_dependency_cycle", value);
-            return;
-        }
-        if (visited.has(value))
-            return;
-        visiting.add(value);
-        for (const dependency of outcomes.get(value).depends_on)
-            if (outcomes.has(dependency))
-                visit(dependency);
-        visiting.delete(value);
-        visited.add(value);
-    };
-    for (const outcome of outcomes.keys())
-        visit(outcome);
-}
-function issue(report, code, detail) {
-    if (!report)
-        fail(code, detail);
-    report(`delivery_contract_invalid:${code}:${detail}`);
-}
-function captureOrReport(report, action) {
-    if (!report) {
-        action();
-        return;
-    }
-    try {
-        action();
-    }
-    catch (error) {
-        report(error instanceof Error ? error.message : String(error));
-    }
-}

package/dist/lib/long-task-design-feasibility-binding-owners.d.ts

@@ -1,6 +0,0 @@
-import type { DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
-import type { DeliveryBindingV2 } from "./long-task-delivery-types.js";
-type FeasibleRealization = DesignResourceImplementationFeasibilityV1["component_family_cells"][number]["feasible_realizations"][number];
-export declare function matchingFeasibilityBindingKeys(realization: FeasibleRealization, bindings: DeliveryBindingV2[]): Set<string>;
-export declare function validateFeasibilityBindingOwnerRoots(document: DesignResourceImplementationFeasibilityV1, componentBindings: DeliveryBindingV2[], routeBinding: DeliveryBindingV2): void;
-export {};

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

@@ -1,52 +0,0 @@
-import { invalid } from "./long-task-design-resource-method-binding.js";
-import { matchesRepoPattern, proveRepositoryPatternSubset, } from "./long-task-paths.js";
-export function matchingFeasibilityBindingKeys(realization, bindings) {
-    const result = new Set();
-    for (const owner of realization.owner_candidates)
-        for (const binding of bindings) {
-            if (binding.existence !== owner.existence)
-                continue;
-            const matches = owner.kind === "planned_logical_owner"
-                ? binding.key === owner.locator || binding.target === owner.locator
-                : (binding.kind === "file" && binding.target === owner.locator) ||
-                    binding.carrier_paths.some((pattern) => matchesRepoPattern(owner.locator, pattern));
-            if (matches)
-                result.add(binding.key);
-        }
-    return result;
-}
-export function validateFeasibilityBindingOwnerRoots(document, componentBindings, routeBinding) {
-    const componentRoots = observedOwnerRoots(document, "component_owner_roots");
-    const routeRoots = observedOwnerRoots(document, "route_owner_roots");
-    if (componentBindings.length && componentRoots.length === 0)
-        invalid("feasibility_component_owner_roots_required", document.target_ref);
-    for (const binding of componentBindings) {
-        if (binding.existence === "planned" && binding.carrier_paths.length === 0)
-            invalid("feasibility_planned_binding_carrier_required", binding.key);
-        proveBindingPathUniverseWithinObservedRoots(binding, componentRoots, "feasibility_component_binding_outside_owner_roots");
-    }
-    if (routeRoots.length === 0)
-        invalid("feasibility_route_owner_roots_required", document.target_ref);
-    proveBindingPathUniverseWithinObservedRoots(routeBinding, routeRoots, "feasibility_route_binding_outside_owner_roots");
-}
-function proveBindingPathUniverseWithinObservedRoots(binding, roots, errorCode) {
-    for (const candidate of bindingPathUniverse(binding)) {
-        const proofs = roots.map((root) => proveRepositoryPatternSubset(candidate, `${root.replace(/\/+$/u, "")}/**`));
-        if (proofs.some((proof) => proof.status === "proven_subset"))
-            continue;
-        const proof = proofs[0];
-        invalid(errorCode, `${binding.key}:${candidate}:${proof?.status ?? "unknown"}:${proof?.reason ?? "owner_roots_empty"}:${roots.join(",")}`);
-    }
-}
-function observedOwnerRoots(document, kind) {
-    const observation = document.substrate_observations.find((candidate) => candidate.kind === kind);
-    return observation?.disposition === "observed" &&
-        observation.value?.kind === "repository_paths"
-        ? observation.value.paths
-        : [];
-}
-function bindingPathUniverse(binding) {
-    return binding.kind === "verified"
-        ? [...binding.carrier_paths]
-        : [binding.target, ...binding.carrier_paths];
-}

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

@@ -1,13 +0,0 @@
-import type { DesignResourceHandoffPreflightV1 } 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";
-import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
-type DesignResourcePreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
-export interface LongTaskDesignFeasibilityBindingValidationResult {
-    consumed_component_binding_refs: string[];
-}
-export interface LongTaskDesignFeasibilityBindingValidationOptions {
-    deferComponentBindingAttribution?: boolean;
-}
-export declare function validateLongTaskDesignFeasibilityBindings(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, preflight: DesignResourcePreflight, sourceItems: CompiledSourceItemV2[], options?: LongTaskDesignFeasibilityBindingValidationOptions): LongTaskDesignFeasibilityBindingValidationResult;
-export {};

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 {
-            consumed_component_binding_refs: [
-                ...contractTarget.binding.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 {
-        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,78 +0,0 @@
-import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, requireExactFeasibilityDecisionProjection, } from "./design-resource-implementation-feasibility-source-decision.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}`));
-        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.impact_claims.some((claimRef) => impactedTargetClaims.has(claimRef)))
-                invalid("feasibility_blocker_confirmation_target_claim_missing", `${blocker.key}:${confirmationRef}`);
-        }
-    }
-}
-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-resource-handoff.d.ts

@@ -1,18 +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 declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[]): Promise<void>;
-export declare function createLongTaskDesignHandoffConsumer(contract: DeliveryContractV2, sourceItems?: CompiledSourceItemV2[]): LongTaskDesignHandoffConsumer;