project-tiny-context-harness 0.11.0 → 0.12.1

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

@@ -1,175 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import { validateCounterfactualBindingClaims, validateGlobalCounterfactualBindingClaims, } from "./long-task-counterfactual-claim-policy.js";
-import { assertRepositoryPattern, matchesRepoPattern, proveRepositoryPatternSubset, repositoryPatternsMayOverlap, } from "./long-task-paths.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
-import { mutateSemanticText } from "./long-task-semantic-mutation.js";
-export function validateVerificationInputSeparation(contract, checks, workdirRelative) {
-    const implementation = contract.outcomes.flatMap((outcome) => [
-        ...outcome.technical.expected_change_paths,
-        ...outcome.technical.allowed_support_paths,
-    ]);
-    for (const check of checks)
-        for (const source of Object.keys(check.verification_input_hashes)) {
-            if (implementation.some((pattern) => repositoryPatternsMayOverlap(pattern, source)))
-                throw new Error(`verification_input_overlaps_implementation:${check.key}:${source}`);
-            if (source === workdirRelative ||
-                source.startsWith(`${workdirRelative}/`) ||
-                source === ".git" ||
-                source.startsWith(".git/") ||
-                source.split("/").includes("node_modules") ||
-                check.artifact_globs.some((artifact) => repositoryPatternsMayOverlap(artifact, source)))
-                throw new Error(`verification_input_protected:${check.key}:${source}`);
-        }
-}
-export function validateTechnicalPaths(contract, repository, workdirRelative, baseline) {
-    const forbidden = [
-        ...contract.global.technical.forbidden_paths.map((entry) => entry.path),
-        ...contract.outcomes.flatMap((outcome) => outcome.technical.forbidden_paths),
-    ].map((pattern, index) => assertRepositoryPattern(repository, pattern, `forbidden_paths[${index}]`));
-    for (const outcome of contract.outcomes) {
-        const allowed = [
-            ...outcome.technical.expected_change_paths,
-            ...outcome.technical.allowed_support_paths,
-        ].map((pattern, index) => assertRepositoryPattern(repository, pattern, `${outcome.key}.allowed_paths[${index}]`));
-        for (const pattern of allowed) {
-            if (repositoryPatternsMayOverlap(pattern, workdirRelative))
-                throw new Error(`protected_path_declared:long_task_workdir:${pattern}`);
-            if (forbidden.some((blocked) => repositoryPatternsMayOverlap(pattern, blocked)))
-                throw new Error(`allowed_forbidden_path_overlap:${pattern}`);
-        }
-        for (const binding of outcome.technical.bindings) {
-            const carriers = binding.carrier_paths.map((carrier) => assertRepositoryPattern(repository, carrier, `${outcome.key}.${binding.key}.carrier_path`));
-            for (const carrier of carriers) {
-                if (binding.existence === "existing" &&
-                    !baseline.files.some((file) => matchesRepoPattern(file.path, carrier)))
-                    throw new Error(`binding_carrier_path_not_found:${outcome.key}:${carrier}`);
-                if (!allowed.some((pattern) => proveRepositoryPatternSubset(carrier, pattern).status ===
-                    "proven_subset"))
-                    throw new Error(`binding_carrier_outside_change_paths:${outcome.key}:${carrier}`);
-            }
-            if (binding.kind === "file") {
-                const target = assertRepositoryPattern(repository, binding.target, `${outcome.key}.${binding.key}.target`);
-                if (!carriers.some((carrier) => matchesRepoPattern(target, carrier)))
-                    throw new Error(`binding_target_outside_carrier:${outcome.key}:${binding.key}`);
-            }
-            if (binding.kind === "path_glob") {
-                const target = assertRepositoryPattern(repository, binding.target, `${outcome.key}.${binding.key}.target`);
-                if (binding.existence === "existing" &&
-                    !baseline.files.some((file) => matchesRepoPattern(file.path, target)))
-                    throw new Error(`binding_target_not_found:${outcome.key}:${binding.key}`);
-            }
-        }
-    }
-}
-export async function validateCounterfactualPaths(contract, compiledGlobalChecks, compiledOutcomes, repository, workdirRelative, protectedAuthorityPaths) {
-    const allChecks = [
-        ...compiledGlobalChecks,
-        ...compiledOutcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-    const protectedInputs = new Set([
-        ...contract.task.source_paths,
-        ...protectedAuthorityPaths,
-        ...allChecks.flatMap((check) => [
-            ...Object.keys(check.verification_input_hashes),
-            check.runner.resolved_target,
-        ]),
-    ]);
-    for (const outcome of contract.outcomes) {
-        const compiled = compiledOutcomes.find((item) => item.key === outcome.key);
-        for (const control of outcome.acceptance.counterfactual_controls) {
-            const binding = outcome.technical.bindings.find((item) => item.key === control.binding_key);
-            if (!binding)
-                throw new Error(`counterfactual_binding_unknown:${outcome.key}:${control.key}:${control.binding_key}`);
-            validateCounterfactualBindingClaims(outcome, control, binding);
-            const check = compiled.acceptance.checks.find((item) => item.key === control.check_key);
-            await validateScopeCounterfactualPaths({
-                scope: outcome.key,
-                controlKey: control.key,
-                mutation: control.mutation,
-                binding,
-                check,
-                repository,
-                workdirRelative,
-                protectedInputs,
-            });
-        }
-    }
-    for (const control of contract.global.acceptance.counterfactual_controls) {
-        const { outcome, binding } = validateGlobalCounterfactualBindingClaims(contract, control);
-        const check = compiledGlobalChecks.find((item) => item.key === control.check_key);
-        await validateScopeCounterfactualPaths({
-            scope: "GLOBAL",
-            controlKey: control.key,
-            mutation: control.mutation,
-            binding,
-            check,
-            repository,
-            workdirRelative,
-            protectedInputs,
-            bindingRef: `${outcome.key}.${binding.key}`,
-        });
-    }
-}
-async function validateScopeCounterfactualPaths(options) {
-    const mutated = options.mutation.type === "remove_paths"
-        ? options.mutation.paths
-        : [options.mutation.path];
-    for (const relative of mutated) {
-        const target = resolveInsideRepository(options.repository, relative, `${options.scope}.counterfactual`);
-        const normalized = repoRelative(options.repository, target);
-        if (options.protectedInputs.has(normalized))
-            throw new Error(`counterfactual_verification_input_protected:${options.scope}:${relative}`);
-        if (normalized === options.workdirRelative ||
-            normalized.startsWith(`${options.workdirRelative}/`) ||
-            normalized === ".git" ||
-            normalized.startsWith(".git/") ||
-            normalized.split("/").includes("node_modules"))
-            throw new Error(`counterfactual_path_protected:${options.scope}:${relative}`);
-        if (!options.binding.carrier_paths.some((pattern) => proveRepositoryPatternSubset(normalized, pattern).status ===
-            "proven_subset"))
-            throw new Error(`counterfactual_path_outside_binding:${options.scope}:${options.controlKey}:${relative}`);
-        if (options.binding.existence === "existing" &&
-            !(await stat(target).catch(() => null)))
-            throw new Error(`counterfactual_path_not_found:${options.scope}:${relative}`);
-    }
-    if (options.mutation.type === "replace_json_value" ||
-        options.mutation.type === "replace_text") {
-        const replacementTarget = resolveInsideRepository(options.repository, options.mutation.path, `${options.scope}.counterfactual.path`);
-        if (!(await stat(replacementTarget).catch(() => null)))
-            return;
-        try {
-            mutateSemanticText(await readFile(replacementTarget, "utf8"), options.mutation, false);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`counterfactual_semantic_mutation_invalid:${options.scope}:${options.controlKey}:${message}`);
-        }
-        return;
-    }
-    if (options.mutation.type !== "replace_file")
-        return;
-    const fixtureTarget = resolveInsideRepository(options.repository, options.mutation.fixture_path, `${options.scope}.counterfactual.fixture`);
-    const fixture = repoRelative(options.repository, await assertProtectedRepositoryFile(options.repository, fixtureTarget, `${options.scope}.counterfactual.fixture`));
-    if (!Object.hasOwn(options.check.verification_input_hashes, fixture))
-        throw new Error(`counterfactual_fixture_must_be_verification_input:${options.scope}:${fixture}`);
-    const replacementTarget = resolveInsideRepository(options.repository, options.mutation.path, `${options.scope}.counterfactual.path`);
-    if (await stat(replacementTarget).catch(() => null)) {
-        const [fixtureBytes, targetBytes] = await Promise.all([
-            readFile(fixtureTarget),
-            readFile(replacementTarget),
-        ]);
-        if (fixtureBytes.equals(targetBytes))
-            throw new Error(`counterfactual_replacement_must_change_carrier:${options.scope}:${options.controlKey}`);
-    }
-}
-export async function hashDeclaredFiles(repository, files, label) {
-    const result = {};
-    for (const [index, file] of files.entries()) {
-        const target = resolveInsideRepository(repository, file, `${label}[${index}]`);
-        const protectedTarget = await assertProtectedRepositoryFile(repository, target, `${label}[${index}]`);
-        result[repoRelative(repository, protectedTarget)] = sha256Hex(await readFile(protectedTarget));
-    }
-    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
-}

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

@@ -1,6 +0,0 @@
-export * from "./long-task-acceptance-shape.js";
-export * from "./long-task-applicability-shape.js";
-export * from "./long-task-product-shape.js";
-export * from "./long-task-shape-primitives.js";
-export * from "./long-task-source-shape.js";
-export * from "./long-task-technical-shape.js";

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

@@ -1,6 +0,0 @@
-export * from "./long-task-acceptance-shape.js";
-export * from "./long-task-applicability-shape.js";
-export * from "./long-task-product-shape.js";
-export * from "./long-task-shape-primitives.js";
-export * from "./long-task-source-shape.js";
-export * from "./long-task-technical-shape.js";

package/dist/lib/long-task-delivery-types.d.ts

@@ -1,15 +0,0 @@
-export * from "./long-task-contract-types.js";
-export * from "./long-task-control-types.js";
-export * from "./long-task-counterfactual-types.js";
-export * from "./long-task-authority-types.js";
-export * from "./long-task-evidence-adapter-types.js";
-export * from "./long-task-evidence-capability-types.js";
-export * from "./long-task-risk-types.js";
-export * from "./long-task-runtime-types.js";
-export * from "./long-task-semantic-contract-types.js";
-export * from "./long-task-ui-surface-types.js";
-export * from "./long-task-source-authority-types.js";
-export * from "./long-task-workspace-runtime-types.js";
-export * from "./long-task-external-confirmation-types.js";
-export * from "./long-task-completion-types.js";
-export * from "./semantic-fact-types.js";

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

@@ -1,15 +0,0 @@
-export * from "./long-task-contract-types.js";
-export * from "./long-task-control-types.js";
-export * from "./long-task-counterfactual-types.js";
-export * from "./long-task-authority-types.js";
-export * from "./long-task-evidence-adapter-types.js";
-export * from "./long-task-evidence-capability-types.js";
-export * from "./long-task-risk-types.js";
-export * from "./long-task-runtime-types.js";
-export * from "./long-task-semantic-contract-types.js";
-export * from "./long-task-ui-surface-types.js";
-export * from "./long-task-source-authority-types.js";
-export * from "./long-task-workspace-runtime-types.js";
-export * from "./long-task-external-confirmation-types.js";
-export * from "./long-task-completion-types.js";
-export * from "./semantic-fact-types.js";

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

@@ -1,11 +0,0 @@
-import type { CompiledCheckV2, CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-export interface DeliveryContractStructureValidationOptions {
-    allowDeferredDesignComponentBindingClosure?: boolean;
-    deferCompletionAuthorityClosure?: boolean;
-}
-export declare function validateDeliveryContractStructure(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): void;
-export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): string[];
-export declare function validateResolvedCompletionAuthorityClosure(contract: DeliveryContractV2, compiledGlobalChecks: readonly CompiledCheckV2[], compiledOutcomes: readonly CompiledOutcomeV2[], reachability: AcceptanceReachabilityV1 | null, report?: ValidationReporter): void;
-type ValidationReporter = (message: string) => void;
-export {};

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

@@ -1,267 +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);
-    const completionOptions = {
-        defer_completion_authority_closure: options.deferCompletionAuthorityClosure,
-    };
-    validateDeliveryStages(contract, undefined, completionOptions);
-    validateExecutionTargets(contract, undefined, completionOptions);
-    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);
-    const completionOptions = {
-        defer_completion_authority_closure: options.deferCompletionAuthorityClosure,
-    };
-    validateDeliveryStages(contract, report, completionOptions);
-    validateExecutionTargets(contract, report, completionOptions);
-    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)];
-}
-export function validateResolvedCompletionAuthorityClosure(contract, compiledGlobalChecks, compiledOutcomes, reachability, report) {
-    const options = {
-        acceptance_reachability: reachability,
-        compiled_global_checks: compiledGlobalChecks,
-        compiled_outcomes: compiledOutcomes,
-    };
-    validateDeliveryStages(contract, report, options);
-    validateExecutionTargets(contract, report, options);
-}
-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,14 +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 {
-    attribution_mode: "feasibility" | "legacy";
-    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 {};