project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,155 +0,0 @@
-import path from "node:path";
-import { validateContractForActivation } from "./long-task-activation-validation.js";
-import { DELIVERY_CONTRACT_FILE, parseDeliveryContractBundle, } from "./long-task-delivery-parser.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { changedAuthoritySections, computeAuthorityHashes, } from "./long-task-authority.js";
-import { authorityMaterialsChanged, compiledAuthorityMaterials, computeAuthorityMaterials, } from "./long-task-authority-materials.js";
-import { normalizeContextAuthoritySnapshot } from "./long-task-context-authority.js";
-import { assertRiskNotDowngraded, buildAuthorityRevisionProposal, enforceAuthorityRevision, } from "./long-task-authority-revision-enforcement.js";
-import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
-import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
-import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
-import { changedWorkspacePaths, changedWorkspacePathsFromHead, currentGitTree, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
-import { assertWorkspaceScope, classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
-export async function compileDeliveryContract(workdirInput, projectRootInput = process.cwd(), options = {}) {
-    const repository = await repositoryRoot(projectRootInput);
-    const workdir = path.resolve(workdirInput);
-    const workdirRelative = repoRelative(repository, workdir);
-    if (!workdirRelative)
-        throw new Error("long_task_workdir_must_not_be_repository_root");
-    const contractFile = path.join(workdir, DELIVERY_CONTRACT_FILE);
-    const parsed = await parseDeliveryContractBundle(workdir, repository, {
-        validate_structure: false,
-    });
-    const contract = parsed.contract;
-    const validation = await validateContractForActivation({
-        contract,
-        repository,
-        workdir,
-        mode: "fail_fast",
-    });
-    const claims = validation.claims;
-    const risk = validation.risk;
-    const sourceHashes = validation.source_hashes;
-    const sourceItems = validation.source_items;
-    const context = validation.context_snapshot;
-    const current = validation.workspace;
-    const globalChecks = validation.global_checks;
-    const outcomes = validation.outcomes;
-    const contractFiles = Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
-        repoRelative(repository, path.join(workdir, ...relative.split("/"))),
-        hash,
-    ]));
-    const contractHash = sha256Hex(canonicalValueJson(contract));
-    const authorityMaterials = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
-    const previous = options.live_gate
-        ? null
-        : (options.previous_authority ?? null);
-    const existingInitialTaskBase = options.initial_task_base ?? previous?.initial_task_base ?? null;
-    const changedPaths = existingInitialTaskBase
-        ? changedWorkspacePaths(existingInitialTaskBase.workspace_manifest, current)
-        : await changedWorkspacePathsFromHead(repository, workdir);
-    const firstLockManagedPaths = existingInitialTaskBase
-        ? []
-        : await firstLockManagedWorkspacePaths(repository, changedPaths);
-    assertWorkspaceScope(classifyWorkspaceScope(contract, changedPaths, protectedWorkspacePaths({
-        contract_files: contractFiles,
-        source_hashes: sourceHashes,
-        context_hashes: context.sha256,
-        checks: [
-            ...globalChecks,
-            ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
-        ],
-        additional_files: firstLockManagedPaths,
-    })));
-    const initialTaskBase = existingInitialTaskBase ?? {
-        git_commit: current.git_head,
-        git_tree: await currentGitTree(repository),
-        workspace_manifest: current,
-    };
-    await validateActualRiskSurfaces(repository, changedPaths, contract);
-    const verifier = await captureVerifierIdentity(repository, options.require_completion_gate !== false);
-    const allChecks = [
-        ...globalChecks,
-        ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-    const authorityHashes = computeAuthorityHashes(contract);
-    authorityHashes.acceptance_authority_hash = sha256Hex(canonicalValueJson({
-        declared: authorityHashes.acceptance_authority_hash,
-        claim_coverage: claims.summary,
-        frozen_checks: allChecks.map((check) => ({
-            internal_id: check.internal_id,
-            runner_definition: check.runner.definition_sha256,
-            resolved_cwd: check.runner.resolved_cwd,
-            resolved_target: check.runner.resolved_target,
-            package_script: check.runner.package_script,
-            verification_inputs: check.verification_input_hashes,
-            raw_execution_identity: check.raw_execution_identity,
-            evidence_adapter: check.evidence_adapter,
-            observation_authorities: check.observation_authorities,
-            process_runtime_closure: check.process_runtime_closure,
-        })),
-    }));
-    let authorityRevision = options.authority_revision ?? previous?.authority_revision ?? 1;
-    if (previous) {
-        const changes = changedAuthoritySections(previous.authority_hashes, authorityHashes);
-        const contractChanged = previous.contract_sha256 !== contractHash;
-        const materialsChanged = authorityMaterialsChanged(compiledAuthorityMaterials(previous), authorityMaterials);
-        const verifierChanged = verifierAuthorityDiff(previous.verifier_identity, verifier);
-        const authorityChanged = changes.length > 0 ||
-            contractChanged ||
-            materialsChanged ||
-            verifierChanged.verifier_content_changed ||
-            verifierChanged.verifier_runtime_locator_changed;
-        if (authorityChanged && !options.revise)
-            throw new Error("authority_revision_requires_revise_flag");
-        if (options.revise && authorityChanged) {
-            assertRiskNotDowngraded(previous, risk.effective_level, risk.reasons);
-            authorityRevision = previous.authority_revision + 1;
-            const proposal = buildAuthorityRevisionProposal(previous, contract, authorityHashes, authorityMaterials, globalChecks, outcomes, verifier, risk.minimum_level);
-            options.on_authority_revision?.(proposal);
-            if (options.authority_revision_mode !== "diagnose")
-                await enforceAuthorityRevision(proposal, workdir);
-        }
-    }
-    const unsigned = {
-        schema_version: "compiled-long-task-delivery-v2",
-        repository_root: repository,
-        workdir,
-        contract_file: repoRelative(repository, contractFile),
-        contract_sha256: contractHash,
-        contract_files: contractFiles,
-        source_hashes: sourceHashes,
-        source_items: sourceItems,
-        context_snapshot: normalizeContextAuthoritySnapshot(context),
-        verifier_identity: verifier,
-        effective_risk: risk.effective_level,
-        risk_reasons: risk.reasons,
-        baseline_workspace: initialTaskBase.workspace_manifest,
-        initial_task_base: initialTaskBase,
-        authority_hashes: authorityHashes,
-        authority_materials: authorityMaterials,
-        authority_revision: authorityRevision,
-        claim_coverage: claims.summary,
-        semantic_fact_manifest: contract.semantic_fact_manifest,
-        task: contract.task,
-        risk: contract.risk,
-        source_claims: contract.source_claims,
-        stages: contract.stages,
-        global: {
-            applicability: contract.global.applicability,
-            product: contract.global.product,
-            technical: contract.global.technical,
-            acceptance: {
-                checks: globalChecks,
-                counterfactual_controls: contract.global.acceptance.counterfactual_controls,
-                external_confirmations: contract.global.acceptance.external_confirmations,
-            },
-        },
-        outcomes,
-    };
-    return {
-        ...unsigned,
-        compiled_identity: sha256Hex(canonicalValueJson(unsigned)),
-    };
-}

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

@@ -1,14 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
-export interface ParsedDeliveryContractV2 {
-    contract: DeliveryContractV2;
-    contract_files: Record<string, string>;
-    outcome_files: string[];
-}
-export interface ParseDeliveryContractOptions {
-    validate_structure?: boolean;
-}
-export declare function parseDeliveryContract(workdir: string): Promise<DeliveryContractV2>;
-export declare function parseDeliveryContractBundle(workdirInput: string, repositoryInput?: string, options?: ParseDeliveryContractOptions): Promise<ParsedDeliveryContractV2>;
-export declare function parseDeliveryContractText(raw: string): DeliveryContractV2;
-export declare function parseDeliveryContractTextForMigration(raw: string): DeliveryContractV2;

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

@@ -1,135 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { materializeLongTaskCompactCarrier, materializeLongTaskCompactCarrierForMigration, } from "./long-task-compact-carrier.js";
-import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
-import { validateDeliveryContractStructure } from "./long-task-delivery-validation.js";
-import { parseOutcome, parseOutcomeFragment, safeFragmentPath, } from "./long-task-outcome-parser.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { array, literal, object, parseSourceClaims, strings, } from "./long-task-delivery-shape.js";
-import { parseGlobal, parseRisk, parseStages, parseTask, } from "./long-task-root-shape.js";
-import { parseSemanticFactManifestRef } from "./long-task-semantic-fact-shape.js";
-import { repositoryRoot } from "./long-task-workspace.js";
-import { assertNoSemanticDriftMigration, semanticDriftMigrationFields, } from "./long-task-semantic-drift-migration.js";
-export const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
-export async function parseDeliveryContract(workdir) {
-    return (await parseDeliveryContractBundle(workdir)).contract;
-}
-export async function parseDeliveryContractBundle(workdirInput, repositoryInput, options = {}) {
-    const workdir = path.resolve(workdirInput);
-    const file = path.join(workdir, DELIVERY_CONTRACT_FILE);
-    const repository = repositoryInput
-        ? path.resolve(repositoryInput)
-        : await repositoryRoot(workdir);
-    const raw = await readFile(await assertProtectedRepositoryFile(repository, file, "delivery_contract"), "utf8");
-    let root = parseRoot(raw, true);
-    if (Object.hasOwn(root, "compact_semantic_carrier")) {
-        root = materializeLongTaskCompactCarrier(root).root;
-        assertNoSemanticDriftMigration(semanticDriftMigrationFields(root));
-    }
-    const hasInline = Object.hasOwn(root, "outcomes");
-    const hasFiles = Object.hasOwn(root, "outcome_files");
-    if (hasInline === hasFiles)
-        throw new Error("delivery_contract_invalid:$:exactly one of outcomes or outcome_files is required");
-    const files = {};
-    let outcomes;
-    let outcomeFiles = [];
-    if (hasInline) {
-        outcomes = array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`));
-    }
-    else {
-        outcomeFiles = strings(root.outcome_files, "outcome_files")
-            .map((item, index) => safeFragmentPath(item, index))
-            .sort();
-        if (new Set(outcomeFiles).size !== outcomeFiles.length)
-            throw new Error("delivery_contract_invalid:outcome_files:duplicate path");
-        outcomes = [];
-        for (const relative of outcomeFiles) {
-            const target = path.resolve(workdir, ...relative.split("/"));
-            if (!target.startsWith(`${workdir}${path.sep}`))
-                throw new Error(`unsafe_path:outcome_files:${relative}`);
-            const protectedFragment = await assertProtectedRepositoryFile(repository, target, `outcome_fragment:${relative}`).catch((error) => {
-                if (error instanceof Error &&
-                    error.message.startsWith("protected_input_not_found:"))
-                    throw new Error(`outcome_fragment_not_found:${relative}`);
-                throw error;
-            });
-            const fragmentRaw = await readFile(protectedFragment, "utf8");
-            files[relative] = sha256Hex(fragmentRaw);
-            outcomes.push(...parseOutcomeFragment(fragmentRaw, relative));
-        }
-        outcomes.sort((left, right) => left.key.localeCompare(right.key));
-    }
-    const contract = parseContractRoot(root, outcomes);
-    if (options.validate_structure !== false)
-        validateDeliveryContractStructure(contract);
-    return {
-        contract,
-        contract_files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))),
-        outcome_files: outcomeFiles,
-    };
-}
-export function parseDeliveryContractText(raw) {
-    return parseDeliveryContractTextInternal(raw, false);
-}
-export function parseDeliveryContractTextForMigration(raw) {
-    return parseDeliveryContractTextInternal(raw, true);
-}
-function parseDeliveryContractTextInternal(raw, allowLegacyCarrier) {
-    let root = parseRoot(raw, false);
-    if (Object.hasOwn(root, "compact_semantic_carrier")) {
-        root = (allowLegacyCarrier
-            ? materializeLongTaskCompactCarrierForMigration(root)
-            : materializeLongTaskCompactCarrier(root)).root;
-        assertNoSemanticDriftMigration(semanticDriftMigrationFields(root));
-    }
-    const contract = parseContractRoot(root, array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`)));
-    validateDeliveryContractStructure(contract);
-    return contract;
-}
-function parseRoot(raw, bundle) {
-    const decoded = parseStrictYaml(raw);
-    if (decoded &&
-        typeof decoded === "object" &&
-        !Array.isArray(decoded) &&
-        decoded.schema_version ===
-            "long-task-delivery-v1")
-        throw new Error("long_task_delivery_v1_retired_use_v2");
-    if (!decoded ||
-        typeof decoded !== "object" ||
-        Array.isArray(decoded) ||
-        !Object.hasOwn(decoded, "compact_semantic_carrier"))
-        assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
-    const root = object(decoded, "$", [
-        "schema_version",
-        "semantic_fact_manifest",
-        "task",
-        "stages",
-        "risk",
-        "global",
-    ], bundle
-        ? [
-            "source_claims",
-            "compact_semantic_carrier",
-            "outcomes",
-            "outcome_files",
-        ]
-        : ["source_claims", "compact_semantic_carrier", "outcomes"]);
-    const hasExpanded = Object.hasOwn(root, "source_claims");
-    const hasCompact = Object.hasOwn(root, "compact_semantic_carrier");
-    if (hasExpanded === hasCompact)
-        throw new Error("delivery_contract_invalid:$:exactly one of source_claims or compact_semantic_carrier is required");
-    return root;
-}
-function parseContractRoot(root, outcomes) {
-    literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");
-    return {
-        schema_version: "long-task-delivery-v2",
-        semantic_fact_manifest: parseSemanticFactManifestRef(root.semantic_fact_manifest, "semantic_fact_manifest"),
-        task: parseTask(root.task),
-        source_claims: parseSourceClaims(root.source_claims, "source_claims"),
-        stages: parseStages(root.stages),
-        risk: parseRisk(root.risk),
-        global: parseGlobal(root.global),
-        outcomes,
-    };
-}

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

@@ -1,5 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function validateVerificationInputSeparation(contract: DeliveryContractV2, checks: CompiledDeliveryContractV2["outcomes"][number]["acceptance"]["checks"], workdirRelative: string): void;
-export declare function validateTechnicalPaths(contract: DeliveryContractV2, repository: string, workdirRelative: string, baseline: WorkspaceManifestV2): void;
-export declare function validateCounterfactualPaths(contract: DeliveryContractV2, compiledGlobalChecks: CompiledCheckV2[], compiledOutcomes: CompiledOutcomeV2[], repository: string, workdirRelative: string, protectedAuthorityPaths: string[]): Promise<void>;
-export declare function hashDeclaredFiles(repository: string, files: string[], label: string): Promise<Record<string, string>>;

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,13 +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 "./semantic-fact-types.js";

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

@@ -1,13 +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 "./semantic-fact-types.js";

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

@@ -1,6 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export interface DeliveryContractStructureValidationOptions {
-    allowDeferredDesignComponentBindingClosure?: boolean;
-}
-export declare function validateDeliveryContractStructure(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): void;
-export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): string[];