project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-counterfactual-sandbox.js

@@ -1,195 +0,0 @@
-import { copyFile, cp, lstat, mkdir, mkdtemp, readlink, realpath, rm, symlink, } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
-const directProcessExecutionSandboxes = new WeakMap();
-const TRANSIENT_REMOVE_CODES = new Set([
-    "EBUSY",
-    "EMFILE",
-    "ENFILE",
-    "ENOTEMPTY",
-    "EPERM",
-]);
-const REMOVE_RETRY_LIMIT = process.platform === "win32" ? 6 : 2;
-const REMOVE_RETRY_DELAY_MS = 100;
-export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest, protectedAuthorityPaths = [], executionUniverse = [check]) {
-    const root = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-"));
-    if (!manifest) {
-        await cp(snapshotRoot, root, {
-            recursive: true,
-            force: true,
-            dereference: false,
-        });
-        return disposable(root, root, null);
-    }
-    const directProcessPaths = directProcessExecutionPaths({
-        check,
-        control,
-        manifest,
-        protected_authority_paths: protectedAuthorityPaths,
-        execution_universe: executionUniverse,
-    });
-    let processExecution = null;
-    if (directProcessPaths) {
-        const processRoot = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-process-"));
-        await copyInBatches(snapshotRoot, processRoot, directProcessPaths);
-        await mkdir(path.join(processRoot, check.runner.resolved_cwd), {
-            recursive: true,
-        });
-        processExecution = {
-            root: processRoot,
-            mutation_source_root: snapshotRoot,
-        };
-    }
-    const exactPaths = new Set([
-        ...Object.keys(check.runner.frozen_files),
-        ...Object.keys(check.verification_input_hashes),
-        ...(check.process_runtime_closure?.allowed_runtime_files ?? []),
-        check.runner.resolved_target,
-        ...(control.mutation.type === "replace_file"
-            ? [control.mutation.fixture_path]
-            : []),
-    ]);
-    const patterns = [
-        ...check.input_paths,
-        ...check.expected_output_paths,
-        ...check.artifact_globs,
-        ...bindingCarrierPaths,
-        ...(control.mutation.type === "remove_paths"
-            ? control.mutation.paths
-            : [control.mutation.path]),
-    ];
-    for (const requirement of check.environment_requirements) {
-        if (requirement.kind === "file")
-            exactPaths.add(requirement.target);
-        if (requirement.kind === "directory")
-            patterns.push(`${requirement.target}/**`);
-    }
-    const candidates = new Set([
-        ...manifest.files.map((file) => file.path),
-        ...protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `counterfactual.protected_authority_paths[${index}]`)),
-    ]);
-    const selected = [...candidates].filter((relative) => exactPaths.has(relative) ||
-        patterns.some((pattern) => matchesRepoPattern(relative, pattern)));
-    await copyInBatches(snapshotRoot, root, selected);
-    await mkdir(path.join(root, check.runner.resolved_cwd), { recursive: true });
-    await linkDependencyRoots(snapshotRoot, root, check.runner.resolved_cwd);
-    return disposable(root, root, processExecution);
-}
-export function counterfactualSandboxProcessExecution(sandbox) {
-    return directProcessExecutionSandboxes.get(sandbox) ?? null;
-}
-function directProcessExecutionPaths(input) {
-    const checks = [
-        ...new Map([
-            input.check,
-            ...input.execution_universe.filter((candidate) => candidate.raw_execution_identity ===
-                input.check.raw_execution_identity),
-        ].map((candidate) => [candidate.internal_id, candidate])).values(),
-    ];
-    const processChecks = checks.filter((candidate) => (candidate.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"));
-    if (!processChecks.some((candidate) => candidate === input.check))
-        return null;
-    const closures = processChecks.map((candidate) => candidate.process_runtime_closure ?? null);
-    if (closures.some((closure) => closure === null))
-        return null;
-    const closureIdentities = new Set(closures.map((closure) => closure.closure_identity));
-    if (closureIdentities.size !== 1)
-        return null;
-    const primaryClosure = input.check.process_runtime_closure;
-    const mutationTargets = input.control.mutation.type === "remove_paths"
-        ? input.control.mutation.paths
-        : [input.control.mutation.path];
-    if (mutationTargets.some((target) => !primaryClosure.production_carrier_files.includes(target) ||
-        input.protected_authority_paths.some((pattern) => matchesRepoPattern(target, pattern))))
-        return null;
-    const replacementFixture = input.control.mutation.type === "replace_file"
-        ? input.control.mutation.fixture_path
-        : null;
-    if (replacementFixture !== null &&
-        !input.manifest.files.some((file) => file.path === replacementFixture))
-        return null;
-    const selected = new Set();
-    for (const candidate of checks)
-        for (const authority of candidate.observation_authorities ?? []) {
-            if (authority.authority !== "package_static_json_exact" &&
-                authority.authority !== "package_process_json_exact")
-                continue;
-            for (const pattern of authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths))
-                for (const file of input.manifest.files)
-                    if (matchesRepoPattern(file.path, pattern))
-                        selected.add(file.path);
-            if (authority.authority === "package_process_json_exact")
-                for (const file of candidate.process_runtime_closure
-                    .allowed_runtime_files)
-                    if (input.manifest.files.some((entry) => entry.path === file))
-                        selected.add(file);
-        }
-    return [...selected]
-        .filter((file) => !input.protected_authority_paths.some((pattern) => matchesRepoPattern(file, pattern)))
-        .sort();
-}
-async function copyInBatches(sourceRoot, targetRoot, paths) {
-    const concurrency = 32;
-    for (let index = 0; index < paths.length; index += concurrency)
-        await Promise.all(paths
-            .slice(index, index + concurrency)
-            .map((relative) => copyEntry(path.join(sourceRoot, relative), path.join(targetRoot, relative))));
-}
-async function copyEntry(source, target) {
-    await mkdir(path.dirname(target), { recursive: true });
-    const info = await lstat(source);
-    if (!info.isSymbolicLink()) {
-        await copyFile(source, target);
-        return;
-    }
-    const link = await readlink(source);
-    if (process.platform === "win32")
-        await symlink(link, target, "junction");
-    else
-        await symlink(link, target);
-}
-async function linkDependencyRoots(sourceRoot, targetRoot, resolvedCwd) {
-    const segments = resolvedCwd === "." ? [] : resolvedCwd.split("/");
-    for (let length = 0; length <= segments.length; length += 1) {
-        const relative = path.join(...segments.slice(0, length), "node_modules");
-        const source = path.join(sourceRoot, relative);
-        if (!(await lstat(source).catch(() => null)))
-            continue;
-        const target = path.join(targetRoot, relative);
-        await mkdir(path.dirname(target), { recursive: true });
-        await rm(target, { recursive: true, force: true });
-        await symlink(await realpath(source), target, process.platform === "win32" ? "junction" : "dir");
-    }
-}
-function disposable(root, mutationSourceRoot, processExecution) {
-    const sandbox = {
-        root,
-        mutation_source_root: mutationSourceRoot,
-        async dispose() {
-            directProcessExecutionSandboxes.delete(sandbox);
-            await Promise.all([processExecution?.root, root]
-                .filter((candidate) => Boolean(candidate))
-                .map((candidate) => removeCounterfactualSandboxRoot(candidate)));
-        },
-    };
-    if (processExecution)
-        directProcessExecutionSandboxes.set(sandbox, processExecution);
-    return sandbox;
-}
-export async function removeCounterfactualSandboxRoot(root, removeTree = rm, wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))) {
-    for (let attempt = 0;; attempt += 1) {
-        try {
-            await removeTree(root, { recursive: true, force: true });
-            return;
-        }
-        catch (error) {
-            const code = error && typeof error === "object" && "code" in error
-                ? String(error.code)
-                : "";
-            if (!TRANSIENT_REMOVE_CODES.has(code) || attempt >= REMOVE_RETRY_LIMIT)
-                throw error;
-            await wait(REMOVE_RETRY_DELAY_MS * (attempt + 1));
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-export type CounterfactualMutationV2 = {
-    type: "remove_paths";
-    paths: string[];
-} | {
-    type: "replace_file";
-    path: string;
-    fixture_path: string;
-} | {
-    type: "replace_json_value";
-    path: string;
-    pointer: string;
-    value: unknown;
-} | {
-    type: "replace_text";
-    path: string;
-    match: string;
-    replacement: string;
-};
-export interface CounterfactualControlV2 {
-    key: string;
-    binding_key: string;
-    claims: string[];
-    check_key: string;
-    mutation: CounterfactualMutationV2;
-    expected_assertion_failures: string[];
-    preserved_assertions: string[];
-    allowed_fanout_assertions: string[];
-}
-export interface GlobalCounterfactualControlV2 {
-    key: string;
-    binding_ref: string;
-    claims: string[];
-    check_key: string;
-    mutation: CounterfactualMutationV2;
-    expected_assertion_failures: string[];
-    preserved_assertions: string[];
-    allowed_fanout_assertions: string[];
-}

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

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

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

@@ -1,24 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, ContextAuthoritySnapshotV2, DeliveryContractV2, InitialTaskBaseV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-interface CompileWorkspaceGuardOptions {
-    live_gate?: boolean;
-    initial_task_base?: InitialTaskBaseV2;
-    previous_authority?: CompiledDeliveryContractV2 | null;
-}
-interface CompileWorkspaceGuardInput {
-    repository: string;
-    workdir: string;
-    options: CompileWorkspaceGuardOptions;
-    contract: DeliveryContractV2;
-    contract_files: Record<string, string>;
-    source_hashes: Record<string, string>;
-    context_snapshot: ContextAuthoritySnapshotV2;
-    workspace: WorkspaceManifestV2;
-    global_checks: CompiledCheckV2[];
-    outcomes: CompiledOutcomeV2[];
-}
-interface CompileWorkspaceGuardResult {
-    previous: CompiledDeliveryContractV2 | null;
-    initial_task_base: InitialTaskBaseV2;
-}
-export declare function prepareCompileWorkspaceGuard(input: CompileWorkspaceGuardInput): Promise<CompileWorkspaceGuardResult>;
-export {};

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

@@ -1,32 +0,0 @@
-import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
-import { changedWorkspacePaths, changedWorkspacePathsFromHead, currentGitTree, } from "./long-task-workspace.js";
-import { assertWorkspaceScope, classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
-export async function prepareCompileWorkspaceGuard(input) {
-    const previous = input.options.live_gate
-        ? null
-        : (input.options.previous_authority ?? null);
-    const existingInitialTaskBase = input.options.initial_task_base ?? previous?.initial_task_base ?? null;
-    const changedPaths = existingInitialTaskBase
-        ? changedWorkspacePaths(existingInitialTaskBase.workspace_manifest, input.workspace)
-        : await changedWorkspacePathsFromHead(input.repository, input.workdir);
-    const firstLockManagedPaths = existingInitialTaskBase
-        ? []
-        : await firstLockManagedWorkspacePaths(input.repository, changedPaths);
-    assertWorkspaceScope(classifyWorkspaceScope(input.contract, changedPaths, protectedWorkspacePaths({
-        contract_files: input.contract_files,
-        source_hashes: input.source_hashes,
-        context_hashes: input.context_snapshot.sha256,
-        checks: [
-            ...input.global_checks,
-            ...input.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-        ],
-        additional_files: firstLockManagedPaths,
-    })));
-    const initialTaskBase = existingInitialTaskBase ?? {
-        git_commit: input.workspace.git_head,
-        git_tree: await currentGitTree(input.repository),
-        workspace_manifest: input.workspace,
-    };
-    await validateActualRiskSurfaces(input.repository, changedPaths, input.contract);
-    return { previous, initial_task_base: initialTaskBase };
-}

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

@@ -1,14 +0,0 @@
-import type { CompiledDeliveryContractV2, InitialTaskBaseV2 } from "./long-task-delivery-types.js";
-import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
-export interface CompileDeliveryOptionsV2 {
-    require_completion_gate?: boolean;
-    revise?: boolean;
-    live_gate?: boolean;
-    initial_task_base?: InitialTaskBaseV2;
-    authority_revision?: number;
-    previous_authority?: CompiledDeliveryContractV2 | null;
-    authority_revision_mode?: "enforce" | "diagnose";
-    on_authority_revision?: (proposal: AuthorityRevisionProposalV2) => void;
-}
-export declare function compileDeliveryContract(workdirInput: string, projectRootInput?: string, options?: CompileDeliveryOptionsV2): Promise<CompiledDeliveryContractV2>;
-export declare function compiledAcceptanceAuthorityHash(declaredHash: string, claimCoverage: unknown, acceptanceReachability: unknown, frozenChecks: unknown): string;

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

@@ -1,170 +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 { captureVerifierIdentity } from "./long-task-verifier-identity.js";
-import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
-import { canonicalExistingLongTaskWorkdir, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
-import { compileExternalConfirmationIdentityAssurances } from "./long-task-external-confirmation-attestation.js";
-import { assertNoUnfinishedContextMutationForAuthority } from "./context-mutation/mutation-journal.js";
-import { currentActiveAuthorityLockToken } from "./long-task-active-authority-lock-context.js";
-import { withActiveAuthorityLock } from "./long-task-state.js";
-import { prepareCompileWorkspaceGuard } from "./long-task-delivery-compiler-preflight.js";
-export async function compileDeliveryContract(workdirInput, projectRootInput = process.cwd(), options = {}) {
-    const repository = await repositoryRoot(projectRootInput);
-    const compile = () => compileDeliveryContractLocked(workdirInput, repository, options);
-    if (currentActiveAuthorityLockToken(repository))
-        return compile();
-    return withActiveAuthorityLock(repository, "compile", compile);
-}
-async function compileDeliveryContractLocked(workdirInput, repository, options) {
-    // The shared lock stays held while every Context, Source and Design input is
-    // captured. commitActiveAuthority repeats freshness under a later lock when
-    // compilation and binding are separate calls.
-    await assertNoUnfinishedContextMutationForAuthority(repository);
-    const workdir = await canonicalExistingLongTaskWorkdir(repository, 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, initial_task_base: initialTaskBase } = await prepareCompileWorkspaceGuard({
-        repository,
-        workdir,
-        options,
-        contract,
-        contract_files: contractFiles,
-        source_hashes: sourceHashes,
-        context_snapshot: context,
-        workspace: current,
-        global_checks: globalChecks,
-        outcomes,
-    });
-    const verifier = await captureVerifierIdentity(repository, options.require_completion_gate !== false);
-    const allChecks = [
-        ...globalChecks,
-        ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-    const authorityHashes = computeAuthorityHashes(contract);
-    const externalConfirmationIdentityAssurances = await compileExternalConfirmationIdentityAssurances({
-        contract,
-        repository,
-        source_hashes: sourceHashes,
-        context_snapshot: context,
-    });
-    authorityHashes.acceptance_authority_hash = compiledAcceptanceAuthorityHash(authorityHashes.acceptance_authority_hash, claims.summary, validation.acceptance_reachability, 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,
-        completion_role: check.completion_role,
-        expected_authority_refs: check.expected_authority_refs,
-        required_evidence_capabilities: check.required_evidence_capabilities,
-    })));
-    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),
-        project_design_authority: validation.project_design_authority,
-        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,
-        acceptance_reachability: validation.acceptance_reachability,
-        external_confirmation_identity_assurances: externalConfirmationIdentityAssurances,
-        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)),
-    };
-}
-export function compiledAcceptanceAuthorityHash(declaredHash, claimCoverage, acceptanceReachability, frozenChecks) {
-    return sha256Hex(canonicalValueJson({
-        declared: declaredHash,
-        claim_coverage: claimCoverage,
-        acceptance_reachability: acceptanceReachability,
-        frozen_checks: frozenChecks,
-    }));
-}

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

@@ -1,17 +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[];
-    compatibility: {
-        completion_authority_defaulted_to_machine_only: boolean;
-    };
-}
-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,153 +0,0 @@
-import { readFile, realpath } 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 { canonicalExistingLongTaskWorkdir, 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 repository = repositoryInput
-        ? await realpath(path.resolve(repositoryInput))
-        : await repositoryRoot(workdirInput);
-    const workdir = await canonicalExistingLongTaskWorkdir(repository, workdirInput);
-    const file = path.join(workdir, DELIVERY_CONTRACT_FILE);
-    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);
-    const completionAuthorityDefaulted = targetProfileCompletionAuthorityMissing(root);
-    if (options.validate_structure !== false)
-        validateDeliveryContractStructure(contract, {
-            deferCompletionAuthorityClosure: true,
-        });
-    return {
-        contract,
-        contract_files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))),
-        outcome_files: outcomeFiles,
-        compatibility: {
-            completion_authority_defaulted_to_machine_only: completionAuthorityDefaulted,
-        },
-    };
-}
-function targetProfileCompletionAuthorityMissing(root) {
-    const task = root.task;
-    if (!task || typeof task !== "object" || Array.isArray(task))
-        return false;
-    const targetProfile = task.target_profile;
-    return Boolean(targetProfile &&
-        typeof targetProfile === "object" &&
-        !Array.isArray(targetProfile) &&
-        !Object.hasOwn(targetProfile, "completion_authority"));
-}
-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, {
-        deferCompletionAuthorityClosure: true,
-    });
-    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>>;