project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,266 +0,0 @@
-import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
-import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
-import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
-import type { ApplicableKeyedStatementV2, CheckExecutionTargetV2, ClaimApplicabilityV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
-import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
-import type { SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
-export type SourceClaimDispositionV2 = {
-    type: "claim";
-    refs: string[];
-} | {
-    type: "acceptance";
-    refs: [string];
-} | {
-    type: "outcome_result";
-    ref: string;
-} | {
-    type: "global_constraint";
-    refs: string[];
-} | {
-    type: "risk_fact";
-    refs: string[];
-} | {
-    type: "external_confirmation";
-    refs: string[];
-} | {
-    type: "decision_required";
-    reason: string;
-};
-export interface SourceClaimV2 {
-    key: string;
-    source_ref: string;
-    statement: string;
-    disposition: SourceClaimDispositionV2;
-}
-export interface KeyedPathV2 {
-    key: string;
-    path: string;
-}
-export interface ExternalConfirmationV2 {
-    key: string;
-    description: string;
-    owner: string;
-    kind: ExternalConfirmationKindV2;
-    impact_claims: string[];
-    blocks_target: boolean;
-}
-export type ProofSurface = "ui_browser" | "runtime_behavior" | "api_contract" | "data_state" | "security_boundary" | "population_coverage" | "implementation_structure";
-export type RunnerType = "package_script" | "project_binary" | "node_oracle" | "playwright_test";
-export type PresenceOrUnaryAssertionOperator = "exists" | "truthy" | "falsy";
-export type BinaryAssertionOperator = "equals" | "not_equals" | "contains" | "not_contains" | "matches" | "not_matches" | "greater_than" | "greater_or_equal" | "less_than" | "less_or_equal" | "set_equals" | "subset_of" | "superset_of";
-export type AssertionOperator = PresenceOrUnaryAssertionOperator | BinaryAssertionOperator;
-interface DeliveryAssertionBaseV2 {
-    key: string;
-    criterion?: string;
-    claims: string[];
-    applicability_ref?: string;
-    observation: string;
-    evidence_capabilities: EvidenceCapabilityV2[];
-}
-export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
-    operator: PresenceOrUnaryAssertionOperator;
-    expected?: never;
-}) | (DeliveryAssertionBaseV2 & {
-    operator: BinaryAssertionOperator;
-    expected: unknown;
-});
-export interface DeliveryRunnerV2 {
-    type: RunnerType;
-    target: string;
-    argv: string[];
-    cwd: string;
-    timeout_ms: number;
-    effect: "read_only" | "test_sandbox";
-    retry_policy: "none" | "transient_once";
-    idempotent: boolean;
-}
-export type EnvironmentRequirementV2 = {
-    key: string;
-    kind: "executable" | "env_var";
-    target: string;
-} | {
-    key: string;
-    kind: "file" | "directory";
-    target: string;
-} | {
-    key: string;
-    kind: "loopback_tcp";
-    host: "127.0.0.1" | "::1" | "localhost";
-    port: number;
-    timeout_ms: number;
-};
-export interface DeliveryCheckV2 {
-    key: string;
-    journey_roles: DeliveryJourneyRoleV2[];
-    execution_target: CheckExecutionTargetV2;
-    scenario: DeliveryScenarioV2;
-    proof_surface: ProofSurface;
-    runner: DeliveryRunnerV2;
-    verification_inputs: string[];
-    input_paths: string[];
-    expected_output_paths: string[];
-    artifact_globs: string[];
-    positive_assertions: DeliveryAssertionV2[];
-    negative_assertions: DeliveryAssertionV2[];
-    environment_requirements: EnvironmentRequirementV2[];
-}
-export interface DeliveryControlV2 {
-    key: string;
-    surface: string;
-    region: string;
-    location: string;
-    control_type: string;
-    label_content: string;
-    user_task: string;
-    visibility: string;
-    availability: string;
-    trigger: string;
-    input: string;
-    validation: string;
-    default_value: string;
-    interaction: string;
-    navigation_result: string;
-    loading_state: string;
-    empty_state: string;
-    success_state: string;
-    failure_state: string;
-    recovery: string;
-    permission: string;
-    feedback: string;
-    accessibility: string;
-    field_coverage: DeliveryControlFieldCoverageV2[];
-}
-export type DeliveryControlFieldCoverageV2 = {
-    fields: DeliveryControlFieldNameV2[];
-    state: "specified";
-    applicability_refs: string[];
-} | {
-    fields: DeliveryControlFieldNameV2[];
-    state: "not_applicable";
-    statement: string;
-    applicability_refs: string[];
-} | {
-    fields: DeliveryControlFieldNameV2[];
-    state: "unresolved";
-    statement: string;
-    applicability_refs: string[];
-};
-export interface DeliveryControlRelationV2 extends ApplicableKeyedStatementV2 {
-    control_refs: string[];
-    required_proof_surfaces: ProofSurface[];
-}
-export interface DeliveryControlRelationClosureV2 {
-    state: "specified" | "not_applicable" | "unresolved";
-    statement: string;
-    applicability_refs: string[];
-}
-interface DeliveryRequirementV2 extends ApplicableKeyedStatementV2 {
-    required_proof_surfaces: ProofSurface[];
-}
-export interface DeliveryOwnerV2 {
-    label: string;
-    context_refs: string[];
-    path_globs: string[];
-}
-export interface DeliveryObligationV2 extends ApplicableKeyedStatementV2 {
-    required_proof_surfaces: ProofSurface[];
-}
-export interface DeliveryBindingV2 {
-    key: string;
-    kind: "path_glob" | "file" | "verified";
-    target: string;
-    carrier_paths: string[];
-    existence: "existing" | "planned";
-    verification_check_key?: string;
-}
-export interface RollbackRecoveryV2 {
-    rollback: string;
-    recovery: string;
-    verification_check_keys: string[];
-}
-export interface PopulationRequirementV2 {
-    check_key: string;
-    universe_binding_key: string;
-    claims: string[];
-    observations: {
-        universe_ids: string;
-        eligible_ids: string;
-        observed_ids: string;
-        excluded_items: string;
-    };
-    exclusion_rules: KeyedStatementV2[];
-}
-export interface DeliveryOutcomeV2 {
-    key: string;
-    title: string;
-    stage: string;
-    depends_on: string[];
-    applicability: ClaimApplicabilityV2[];
-    semantic_fact_bindings: SemanticFactOutcomeBindingsV2;
-    product: {
-        observable_result: string;
-        result_applicability_refs: string[];
-        success_path_required: boolean;
-        degradation_path_required: boolean;
-        owner: DeliveryOwnerV2;
-        requirements: DeliveryRequirementV2[];
-        owner_surfaces: string[];
-        controls: DeliveryControlV2[];
-        control_relation_closure: DeliveryControlRelationClosureV2;
-        control_relations: DeliveryControlRelationV2[];
-        surface_bindings: DeliverySurfaceBindingV2[];
-        non_completing_outcomes: ApplicableKeyedStatementV2[];
-    };
-    technical: {
-        obligations: DeliveryObligationV2[];
-        expected_change_paths: string[];
-        allowed_support_paths: string[];
-        forbidden_paths: string[];
-        bindings: DeliveryBindingV2[];
-        forbidden_shortcuts: ApplicableKeyedStatementV2[];
-        rollback_and_recovery: RollbackRecoveryV2 | null;
-    };
-    acceptance: {
-        checks: DeliveryCheckV2[];
-        population: PopulationRequirementV2 | null;
-        counterfactual_controls: CounterfactualControlV2[];
-    };
-}
-export interface DeliveryContractV2 {
-    schema_version: "long-task-delivery-v2";
-    semantic_fact_manifest: SemanticFactManifestRefV2;
-    task: {
-        id: string;
-        title: string;
-        goal: string;
-        target_profile: TargetProfileV2;
-        execution_targets: ExecutionTargetV2[];
-        source_paths: string[];
-        context_refs: string[];
-        context_snapshot_mode: "referenced" | "full";
-    };
-    source_claims: SourceClaimV2[];
-    stages: DeliveryStageV2[];
-    risk: {
-        requested_level: RequestedRiskLevel;
-        facts: LongTaskRiskFacts;
-    };
-    global: {
-        applicability: ClaimApplicabilityV2[];
-        product: {
-            non_goals: ApplicableKeyedStatementV2[];
-        };
-        technical: {
-            constraints: ApplicableKeyedStatementV2[];
-            forbidden_paths: KeyedPathV2[];
-            forbidden_shortcuts: ApplicableKeyedStatementV2[];
-        };
-        acceptance: {
-            checks: DeliveryCheckV2[];
-            counterfactual_controls: GlobalCounterfactualControlV2[];
-            external_confirmations: ExternalConfirmationV2[];
-        };
-    };
-    outcomes: DeliveryOutcomeV2[];
-}
-export {};

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

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

package/dist/lib/long-task-control-fields.d.ts

@@ -1,12 +0,0 @@
-import type { DeliveryControlV2 } from "./long-task-contract-types.js";
-import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
-export declare const CONTROL_FIELD_NAMES: readonly ["surface", "region", "location", "control_type", "label_content", "user_task", "visibility", "availability", "trigger", "input", "validation", "default_value", "interaction", "navigation_result", "loading_state", "empty_state", "success_state", "failure_state", "recovery", "permission", "feedback", "accessibility"];
-export interface ControlFieldFactV2 {
-    contract_field: DeliveryControlFieldNameV2;
-    claim_field: string;
-    statement: string;
-    state: "specified" | "not_applicable" | "unresolved";
-    applicability_refs: string[];
-}
-export declare function controlFieldFacts(control: DeliveryControlV2): ControlFieldFactV2[];
-export declare function controlFieldState(control: DeliveryControlV2, field: DeliveryControlFieldNameV2): ControlFieldFactV2["state"];

package/dist/lib/long-task-control-fields.js

@@ -1,66 +0,0 @@
-export const CONTROL_FIELD_NAMES = [
-    "surface",
-    "region",
-    "location",
-    "control_type",
-    "label_content",
-    "user_task",
-    "visibility",
-    "availability",
-    "trigger",
-    "input",
-    "validation",
-    "default_value",
-    "interaction",
-    "navigation_result",
-    "loading_state",
-    "empty_state",
-    "success_state",
-    "failure_state",
-    "recovery",
-    "permission",
-    "feedback",
-    "accessibility",
-];
-const CLAIM_FIELD_BY_CONTRACT_FIELD = {
-    surface: "surface",
-    region: "region",
-    location: "location",
-    control_type: "control_type",
-    label_content: "label_content",
-    user_task: "user_task",
-    visibility: "visibility",
-    availability: "availability",
-    trigger: "trigger",
-    input: "input",
-    validation: "validation",
-    default_value: "default_value",
-    interaction: "interaction",
-    navigation_result: "navigation_result",
-    loading_state: "loading",
-    empty_state: "empty",
-    success_state: "success",
-    failure_state: "failure",
-    recovery: "recovery",
-    permission: "permission",
-    feedback: "feedback",
-    accessibility: "accessibility",
-};
-export function controlFieldFacts(control) {
-    const coverage = new Map(control.field_coverage.flatMap((entry) => entry.fields.map((field) => [field, entry])));
-    return CONTROL_FIELD_NAMES.map((field) => {
-        const entry = coverage.get(field);
-        if (!entry)
-            throw new Error(`control_field_coverage_missing:${control.key}:${field}`);
-        return {
-            contract_field: field,
-            claim_field: CLAIM_FIELD_BY_CONTRACT_FIELD[field],
-            statement: entry.state === "specified" ? control[field] : entry.statement,
-            state: entry.state,
-            applicability_refs: [...entry.applicability_refs],
-        };
-    });
-}
-export function controlFieldState(control, field) {
-    return controlFieldFacts(control).find((candidate) => candidate.contract_field === field).state;
-}

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

@@ -1 +0,0 @@
-export type DeliveryControlFieldNameV2 = "surface" | "region" | "location" | "control_type" | "label_content" | "user_task" | "visibility" | "availability" | "trigger" | "input" | "validation" | "default_value" | "interaction" | "navigation_result" | "loading_state" | "empty_state" | "success_state" | "failure_state" | "recovery" | "permission" | "feedback" | "accessibility";

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

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

package/dist/lib/long-task-counterfactual-claim-policy.d.ts

@@ -1,9 +0,0 @@
-import type { CounterfactualControlV2, DeliveryContractV2, DeliveryBindingV2, DeliveryOutcomeV2, GlobalCounterfactualControlV2 } from "./long-task-delivery-types.js";
-import { type ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
-export declare function validateCounterfactualBindingClaims(outcome: DeliveryOutcomeV2, control: CounterfactualControlV2, binding: DeliveryBindingV2): void;
-export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
-    outcome: DeliveryOutcomeV2;
-};
-export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
-    outcome: DeliveryOutcomeV2;
-};

package/dist/lib/long-task-counterfactual-claim-policy.js

@@ -1,72 +0,0 @@
-import { scopeDeliveryBindings, } from "./long-task-scoped-binding.js";
-export function validateCounterfactualBindingClaims(outcome, control, binding) {
-    if (binding.verification_check_key &&
-        binding.verification_check_key !== control.check_key)
-        throw new Error(`counterfactual_binding_check_mismatch:${outcome.key}:${control.key}:${binding.key}:${control.check_key}`);
-    const check = outcome.acceptance.checks.find((item) => item.key === control.check_key);
-    if (!check)
-        throw new Error(`counterfactual_check_unknown:${outcome.key}:${control.key}:${control.check_key}`);
-    validateExpectedAssertions(control, check, `counterfactual_assertion_unknown:${outcome.key}:${control.key}`);
-    const expectedAssertions = new Set(control.expected_assertion_failures);
-    const expectedClaims = new Set([
-        ...(check?.positive_assertions ?? []),
-        ...(check?.negative_assertions ?? []),
-    ]
-        .filter((assertion) => expectedAssertions.has(assertion.key))
-        .flatMap((assertion) => assertion.claims));
-    if (control.claims.some((claim) => !expectedClaims.has(claim)))
-        throw new Error(`counterfactual_binding_claim_unrelated:${outcome.key}:${control.key}`);
-}
-export function resolveGlobalCounterfactualBinding(contract, control) {
-    const [outcomeKey, bindingKey] = control.binding_ref.split(".");
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    if (!outcome)
-        throw new Error(`global_counterfactual_binding_ref_invalid:${control.key}:${control.binding_ref}`);
-    const scoped = scopeDeliveryBindings(outcome.key, outcome.technical.bindings).find((item) => item.binding_ref === control.binding_ref && item.local_key === bindingKey);
-    if (!scoped)
-        throw new Error(`global_counterfactual_binding_unknown:${control.key}:${control.binding_ref}`);
-    return { outcome, ...scoped };
-}
-export function validateGlobalCounterfactualBindingClaims(contract, control) {
-    const resolved = resolveGlobalCounterfactualBinding(contract, control);
-    const check = contract.global.acceptance.checks.find((item) => item.key === control.check_key);
-    if (!check)
-        throw new Error(`global_counterfactual_check_unknown:${control.key}:${control.check_key}`);
-    validateExpectedAssertions(control, check, `global_counterfactual_assertion_unknown:${control.key}`);
-    const allowedClaims = new Set([
-        ...contract.global.product.non_goals.map((item) => `non_goal.${item.key}`),
-        ...contract.global.technical.constraints.map((item) => `constraint.${item.key}`),
-        ...contract.global.technical.forbidden_shortcuts.map((item) => `forbidden_shortcut.${item.key}`),
-    ]);
-    if (control.claims.some((claim) => !allowedClaims.has(claim)))
-        throw new Error(`global_counterfactual_claim_invalid:${control.key}:${control.claims.filter((claim) => !allowedClaims.has(claim)).join(",")}`);
-    const expectedAssertions = new Set(control.expected_assertion_failures);
-    const expectedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
-        .filter((assertion) => expectedAssertions.has(assertion.key))
-        .flatMap((assertion) => assertion.claims));
-    if (control.claims.some((claim) => !expectedClaims.has(claim)))
-        throw new Error(`global_counterfactual_claim_unrelated:${control.key}`);
-    return resolved;
-}
-function validateExpectedAssertions(control, check, unknownPrefix) {
-    if (!control.expected_assertion_failures.length)
-        throw new Error(`${unknownPrefix}:required`);
-    const assertions = new Set([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key));
-    for (const key of control.expected_assertion_failures)
-        if (!assertions.has(key))
-            throw new Error(`${unknownPrefix}:${key}`);
-    const failures = new Set(control.expected_assertion_failures);
-    const preserved = new Set(control.preserved_assertions);
-    for (const key of control.preserved_assertions) {
-        if (!assertions.has(key))
-            throw new Error(`${unknownPrefix}:${key}`);
-        if (failures.has(key))
-            throw new Error(`counterfactual_preserved_assertion_conflict:${unknownPrefix}:${key}`);
-    }
-    for (const key of control.allowed_fanout_assertions) {
-        if (!assertions.has(key))
-            throw new Error(`${unknownPrefix}:${key}`);
-        if (failures.has(key) || preserved.has(key))
-            throw new Error(`counterfactual_fanout_assertion_conflict:${unknownPrefix}:${key}`);
-    }
-}

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

@@ -1,13 +0,0 @@
-import type { CompiledCheckV2, CounterfactualControlV2, GlobalCounterfactualControlV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export interface CounterfactualSandboxV2 {
-    root: string;
-    dispose(): Promise<void>;
-}
-type RemoveTree = (target: string, options: {
-    recursive: true;
-    force: true;
-}) => Promise<void>;
-type Wait = (milliseconds: number) => Promise<void>;
-export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<CounterfactualSandboxV2>;
-export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
-export {};

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

@@ -1,115 +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 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 = []) {
-    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);
-    }
-    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);
-}
-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) {
-    return {
-        root,
-        async dispose() {
-            await removeCounterfactualSandboxRoot(root);
-        },
-    };
-}
-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.d.ts

@@ -1,13 +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>;