project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-effective-external-takeover.js

@@ -0,0 +1,109 @@
+import { claimObligationRef, sameSet, } from "./long-task-acceptance-reachability-helpers.js";
+export function effectiveBlockingExternalRows(reachability) {
+    return (reachability?.effective_external_routes ?? []).filter((row) => row.authority === "external_confirmation" &&
+        row.status === "external_fulfillable" &&
+        row.completion_role === "blocking" &&
+        row.acceptance_effect === "required");
+}
+function effectivePopulationRows(outcomeKey, reachability) {
+    return effectiveBlockingExternalRows(reachability).filter((row) => row.outcome_key === outcomeKey &&
+        row.proof_surface === "population_coverage" &&
+        row.method === "population_set_equality" &&
+        row.fact_ref !== null &&
+        row.proof_ref !== null &&
+        row.source_obligation_ref === row.proof_ref &&
+        row.required_evidence_capabilities.includes("semantic_fact") &&
+        row.required_evidence_capabilities.includes("population_coverage"));
+}
+function requiredExternalPopulationProofs(outcome, localClaimRef) {
+    return outcome.semantic_fact_bindings.facts
+        .filter((binding) => binding.claim_ref === localClaimRef)
+        .flatMap((factBinding) => outcome.semantic_fact_bindings.proofs
+        .filter((proofBinding) => proofBinding.fact_ref === factBinding.fact_ref &&
+        proofBinding.authority === "external_confirmation" &&
+        proofBinding.method === "population_set_equality" &&
+        proofBinding.proof_surface === "population_coverage")
+        .map((proofBinding) => ({
+        factBinding,
+        proofBinding,
+        confirmationRef: proofBinding.authority === "external_confirmation"
+            ? proofBinding.confirmation_ref
+            : null,
+    })));
+}
+function populationProofRequirementEffectivelyBlocked(outcome, requirement, rows) {
+    const { factBinding, proofBinding, confirmationRef } = requirement;
+    const profile = outcome.applicability.find((candidate) => candidate.key === factBinding.applicability_ref);
+    if (!profile)
+        return false;
+    return (rows.filter((row) => row.claim_ref === `${outcome.key}.${factBinding.claim_ref}` &&
+        row.local_claim_ref === factBinding.claim_ref &&
+        row.applicability_ref === factBinding.applicability_ref &&
+        row.target_ref === profile.target_ref &&
+        row.fact_ref === factBinding.fact_ref &&
+        row.proof_ref === proofBinding.proof_ref &&
+        row.source_obligation_ref === proofBinding.proof_ref &&
+        row.method === proofBinding.method &&
+        row.proof_surface === proofBinding.proof_surface &&
+        row.confirmation_ref === confirmationRef &&
+        sameSet(row.required_evidence_capabilities, proofBinding.evidence_capabilities)).length === 1);
+}
+function populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows) {
+    const requirements = requiredExternalPopulationProofs(outcome, localClaimRef);
+    return (requirements.length > 0 &&
+        requirements.every((requirement) => populationProofRequirementEffectivelyBlocked(outcome, requirement, rows)));
+}
+export function outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome, reachability) {
+    const population = outcome.acceptance.population;
+    if (!population?.claims.length)
+        return false;
+    const rows = effectivePopulationRows(outcome.key, reachability);
+    return population.claims.every((localClaimRef) => populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows));
+}
+function effectiveBlockingResultRows(reachability, outcomeKey) {
+    const claimRef = `${outcomeKey}.result`;
+    return effectiveBlockingExternalRows(reachability).filter((row) => {
+        const ordinaryObligationRef = claimObligationRef(claimRef, row.applicability_ref, row.proof_surface);
+        return (row.outcome_key === outcomeKey &&
+            row.claim_ref === claimRef &&
+            row.local_claim_ref === "result" &&
+            row.fact_ref === null &&
+            row.proof_ref === null &&
+            row.source_obligation_ref === ordinaryObligationRef);
+    });
+}
+export function resultApplicabilityEffectivelyExternallyBlocked(reachability, outcomeKey, applicabilityRef, targetRef) {
+    const rows = effectiveBlockingResultRows(reachability, outcomeKey).filter((row) => row.applicability_ref === applicabilityRef &&
+        row.target_ref === targetRef);
+    return rows.length === 1;
+}
+export function resultApplicabilityProfiles(outcome, options = {}) {
+    const profiles = new Map(outcome.applicability.map((profile) => [profile.key, profile]));
+    return outcome.product.result_applicability_refs
+        .map((ref) => profiles.get(ref))
+        .filter((profile) => Boolean(profile))
+        .filter((profile) => (options.target_ref === undefined ||
+        profile.target_ref === options.target_ref) &&
+        (options.journey_role === undefined ||
+            profile.journey_role === options.journey_role));
+}
+export function outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability, options = {}) {
+    const profiles = resultApplicabilityProfiles(outcome, options);
+    if (!profiles.length)
+        return false;
+    const requiredRefs = new Set(profiles.map((profile) => profile.key));
+    const rows = effectiveBlockingResultRows(reachability, outcome.key).filter((row) => requiredRefs.has(row.applicability_ref));
+    return (rows.length === profiles.length &&
+        profiles.every((profile) => rows.filter((row) => row.applicability_ref === profile.key &&
+            row.target_ref === profile.target_ref).length === 1));
+}
+export function outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability) {
+    if (resultApplicabilityProfiles(outcome).length !==
+        outcome.product.result_applicability_refs.length)
+        return false;
+    return outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability);
+}
+export function allOutcomeResultsFullyEffectivelyExternallyBlocked(contract, reachability) {
+    return (contract.outcomes.length > 0 &&
+        contract.outcomes.every((outcome) => outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability)));
+}

package/dist/lib/long-task-effective-external-ui-takeover.d.ts

@@ -0,0 +1,5 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
+type DeliveryOutcomeV2 = DeliveryContractV2["outcomes"][number];
+export declare function outcomeUiProofFullyEffectivelyExternallyBlocked(contract: DeliveryContractV2, outcome: DeliveryOutcomeV2, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
+export {};

package/dist/lib/long-task-effective-external-ui-takeover.js

@@ -0,0 +1,117 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
+import { designFactObligationDescriptors } from "./long-task-design-obligation.js";
+import { effectiveBlockingExternalRows } from "./long-task-effective-external-takeover.js";
+function designObligationEffectivelyBlocked(descriptor, rows) {
+    return (rows.filter((row) => row.source_obligation_ref === descriptor.source_obligation_ref &&
+        row.claim_ref === descriptor.claim_ref &&
+        row.local_claim_ref === descriptor.local_claim_ref &&
+        row.applicability_ref === descriptor.applicability_ref &&
+        row.proof_surface === descriptor.proof_surface &&
+        row.fact_ref === descriptor.fact_ref &&
+        row.proof_ref === descriptor.source_obligation_ref).length === 1);
+}
+function claimApplicabilityKey(localClaimRef, applicabilityRef) {
+    return `${localClaimRef}\0${applicabilityRef}`;
+}
+function controlClaimApplicabilities(outcome) {
+    const entries = new Set();
+    for (const control of outcome.product.controls)
+        for (const fact of controlFieldFacts(control))
+            for (const applicabilityRef of fact.applicability_refs)
+                entries.add(claimApplicabilityKey(`control.${control.key}.${fact.claim_field}`, applicabilityRef));
+    return entries;
+}
+function designTargetAssertionRefs(target) {
+    return new Set([
+        target.conformance_assertion_ref,
+        ...target.verification_method_bindings.map((binding) => binding.assertion_ref),
+        ...(target.symbolic_method_bindings ?? []).map((binding) => binding.assertion_ref),
+        ...(target.symbolic_certificate_binding
+            ? [target.symbolic_certificate_binding.assertion_ref]
+            : []),
+    ]);
+}
+function addDesignAssertionClaimApplicabilities(entries, check, assertionRefs) {
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ])
+        if (assertionRefs.has(assertion.key) &&
+            assertion.claims.length === 1 &&
+            assertion.applicability_ref)
+            entries.add(claimApplicabilityKey(assertion.claims[0], assertion.applicability_ref));
+}
+function allUiClaimApplicabilities(outcome) {
+    const entries = controlClaimApplicabilities(outcome);
+    for (const surface of outcome.product.surface_bindings)
+        for (const target of surface.design_targets) {
+            const check = outcome.acceptance.checks.find((candidate) => candidate.key === target.conformance_check_ref);
+            if (!check)
+                return null;
+            addDesignAssertionClaimApplicabilities(entries, check, designTargetAssertionRefs(target));
+        }
+    return entries;
+}
+function matchingCoordinates(outcome, localClaimRef, applicabilityRef, targetRef) {
+    return outcome.acceptance.checks.flatMap((check) => [...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => assertionMatchesClaimApplicability(assertion, localClaimRef, applicabilityRef))
+        .map(() => ({
+        local_claim_ref: localClaimRef,
+        applicability_ref: applicabilityRef,
+        target_ref: targetRef,
+        proof_surface: check.proof_surface,
+    })));
+}
+function assertionMatchesClaimApplicability(assertion, localClaimRef, applicabilityRef) {
+    return (assertion.claims.length === 1 &&
+        assertion.claims[0] === localClaimRef &&
+        assertion.applicability_ref === applicabilityRef);
+}
+function coordinateKey(coordinate) {
+    return [
+        coordinate.local_claim_ref,
+        coordinate.applicability_ref,
+        coordinate.target_ref,
+        coordinate.proof_surface,
+    ].join("\0");
+}
+function uiClaimCoordinates(outcome) {
+    const entries = allUiClaimApplicabilities(outcome);
+    if (!entries)
+        return null;
+    const profiles = new Map(outcome.applicability.map((profile) => [profile.key, profile]));
+    const coordinates = new Map();
+    for (const entry of entries) {
+        const [localClaimRef, applicabilityRef] = entry.split("\0");
+        const profile = profiles.get(applicabilityRef);
+        if (!profile)
+            return null;
+        const matching = matchingCoordinates(outcome, localClaimRef, applicabilityRef, profile.target_ref);
+        if (!matching.length)
+            return null;
+        for (const coordinate of matching)
+            coordinates.set(coordinateKey(coordinate), coordinate);
+    }
+    return coordinates;
+}
+function ordinaryUiCoordinateEffectivelyBlocked(outcomeKey, coordinate, rows) {
+    return (rows.filter((row) => row.claim_ref === `${outcomeKey}.${coordinate.local_claim_ref}` &&
+        row.local_claim_ref === coordinate.local_claim_ref &&
+        row.applicability_ref === coordinate.applicability_ref &&
+        row.target_ref === coordinate.target_ref &&
+        row.proof_surface === coordinate.proof_surface &&
+        row.fact_ref === null &&
+        row.proof_ref === null).length === 1);
+}
+export function outcomeUiProofFullyEffectivelyExternallyBlocked(contract, outcome, reachability) {
+    const rows = effectiveBlockingExternalRows(reachability).filter((row) => row.outcome_key === outcome.key);
+    const designObligations = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.outcome_key === outcome.key);
+    if (!designObligations.every((descriptor) => designObligationEffectivelyBlocked(descriptor, rows)))
+        return false;
+    const coordinates = uiClaimCoordinates(outcome);
+    if (!coordinates)
+        return false;
+    if (!designObligations.length && !coordinates.size)
+        return false;
+    return [...coordinates.values()].every((coordinate) => ordinaryUiCoordinateEffectivelyBlocked(outcome.key, coordinate, rows));
+}

package/dist/lib/long-task-evidence-capability-codec.js

@@ -12,6 +12,9 @@ function decodeRecord(value, index) {
     const assertionKey = key(row.assertion_key, `${label}.assertion_key`);
     const capability = nonEmpty(row.capability, `${label}.capability`);
     const base = { assertion_key: assertionKey };
+    const completeDelivery = decodeCompleteDeliveryEvidenceRecord(row, label, base, capability);
+    if (completeDelivery)
+        return completeDelivery;
     switch (capability) {
         case "interaction_trace":
             exact(row, label, [
@@ -196,6 +199,94 @@ function decodeRecord(value, index) {
             throw invalidRecord(`${label}.capability_unsupported:${capability}`);
     }
 }
+function decodeCompleteDeliveryEvidenceRecord(row, label, base, capability) {
+    switch (capability) {
+        case "actual_provenance":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "source_kind",
+                "source_ref",
+                "actual_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                source_kind: literal(row.source_kind, ["product_runtime", "observer_runtime", "durable_store"], `${label}.source_kind`),
+                source_ref: nonEmpty(row.source_ref, `${label}.source_ref`),
+                actual_sha256: sha(row.actual_sha256, `${label}.actual_sha256`),
+            };
+        case "distinct_identity":
+            return decodeDistinctIdentityEvidence(row, label, base);
+        case "data_state":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "state_ref",
+                "state_sha256",
+                "read_session_id",
+            ]);
+            return {
+                ...base,
+                capability,
+                state_ref: nonEmpty(row.state_ref, `${label}.state_ref`),
+                state_sha256: sha(row.state_sha256, `${label}.state_sha256`),
+                read_session_id: nonEmpty(row.read_session_id, `${label}.read_session_id`),
+            };
+        case "population_coverage":
+            return decodePopulationCoverageEvidence(row, label, base);
+        case "recovery":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "failure_session_id",
+                "recovery_session_id",
+                "recovered_state_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                failure_session_id: nonEmpty(row.failure_session_id, `${label}.failure_session_id`),
+                recovery_session_id: nonEmpty(row.recovery_session_id, `${label}.recovery_session_id`),
+                recovered_state_sha256: sha(row.recovered_state_sha256, `${label}.recovered_state_sha256`),
+            };
+        default:
+            return null;
+    }
+}
+function decodeDistinctIdentityEvidence(row, label, base) {
+    exact(row, label, ["assertion_key", "capability", "identities"]);
+    const identities = array(row.identities, `${label}.identities`).map((item, identityIndex) => {
+        const identityLabel = `${label}.identities[${identityIndex}]`;
+        const identity = record(item, identityLabel);
+        exact(identity, identityLabel, ["identity_ref", "data_state_sha256"]);
+        return {
+            identity_ref: nonEmpty(identity.identity_ref, `${identityLabel}.identity_ref`),
+            data_state_sha256: sha(identity.data_state_sha256, `${identityLabel}.data_state_sha256`),
+        };
+    });
+    return { ...base, capability: "distinct_identity", identities };
+}
+function decodePopulationCoverageEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "universe_sha256",
+        "observed_sha256",
+        "excluded_sha256",
+        "set_equality",
+    ]);
+    if (row.set_equality !== true)
+        throw invalidRecord(`${label}.set_equality`);
+    return {
+        ...base,
+        capability: "population_coverage",
+        universe_sha256: sha(row.universe_sha256, `${label}.universe_sha256`),
+        observed_sha256: sha(row.observed_sha256, `${label}.observed_sha256`),
+        excluded_sha256: sha(row.excluded_sha256, `${label}.excluded_sha256`),
+        set_equality: true,
+    };
+}
 function decodeGroundDesignMethodEvidence(row, label, base) {
     exact(row, label, [
         "assertion_key",

package/dist/lib/long-task-evidence-capability-runtime.js

@@ -10,28 +10,28 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes, adm
         case "interaction_trace":
             return validateInteractionTrace(check, record, hostAttestation);
         case "state_delta":
-            if (record.before_sha256 === record.after_sha256)
-                return "state_unchanged";
-            if (!record.changed_fields.length)
-                return "changed_fields_empty";
-            return null;
+            return validateStateDelta(record);
         case "cross_surface_consistency":
             return validateCrossSurfaceConsistency(check, record);
         case "durable_readback":
-            if (record.write_session_id === record.read_session_id)
-                return "independent_session_required";
-            if (record.written_sha256 !== record.read_sha256)
-                return "readback_mismatch";
-            return null;
+            return validateDurableReadback(record);
         case "boundary_invocation":
         case "external_side_effect":
             return validateObserverEvidence(check, record.observer_target_ref);
+        case "actual_provenance":
+            return validateActualProvenance(check, record);
+        case "distinct_identity":
+            return validateDistinctIdentity(record);
+        case "data_state":
+            return validateDataState(record);
+        case "population_coverage":
+            return validatePopulationCoverage(record);
         case "failure_injection":
-            return record.failure_observed ? null : "failure_not_observed";
+            return validateFailureInjection(record);
+        case "recovery":
+            return validateRecovery(record);
         case "visual_render":
-            return artifactHashes[record.artifact_path] === record.artifact_sha256
-                ? null
-                : "artifact_hash_mismatch";
+            return validateVisualRender(record, artifactHashes);
         case "design_conformance":
             return validateDesignConformance(check, record, artifactHashes);
         case "design_method":
@@ -46,6 +46,54 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes, adm
             return validateInputVariation(record);
     }
 }
+function validateStateDelta(record) {
+    if (record.before_sha256 === record.after_sha256)
+        return "state_unchanged";
+    return record.changed_fields.length ? null : "changed_fields_empty";
+}
+function validateDurableReadback(record) {
+    if (record.write_session_id === record.read_session_id)
+        return "independent_session_required";
+    return record.written_sha256 === record.read_sha256
+        ? null
+        : "readback_mismatch";
+}
+function validateActualProvenance(check, record) {
+    return record.source_kind === "observer_runtime" &&
+        check.execution_target_definition.role !== "observer"
+        ? "observer_provenance_target_required"
+        : null;
+}
+function validateDistinctIdentity(record) {
+    if (record.identities.length < 2)
+        return "two_identities_required";
+    if (new Set(record.identities.map((item) => item.identity_ref)).size !==
+        record.identities.length)
+        return "identity_duplicate";
+    return new Set(record.identities.map((item) => item.data_state_sha256)).size <
+        2
+        ? "independent_data_states_required"
+        : null;
+}
+function validateDataState(record) {
+    return record.read_session_id.trim() ? null : "read_session_required";
+}
+function validatePopulationCoverage(record) {
+    return record.set_equality ? null : "set_equality_required";
+}
+function validateFailureInjection(record) {
+    return record.failure_observed ? null : "failure_not_observed";
+}
+function validateRecovery(record) {
+    return record.failure_session_id === record.recovery_session_id
+        ? "independent_recovery_session_required"
+        : null;
+}
+function validateVisualRender(record, artifactHashes) {
+    return artifactHashes[record.artifact_path] === record.artifact_sha256
+        ? null
+        : "artifact_hash_mismatch";
+}
 function validateAdmittedObservationRecord(check, record, admitted) {
     if (record.capability === "semantic_fact" &&
         record.observer_results.length > 0)

package/dist/lib/long-task-evidence-capability-types.d.ts

@@ -2,6 +2,8 @@ import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.j
 import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
 import type { SemanticFactEnvironmentV1, SemanticFactLocatedValueV1, SemanticFactOracleV1 } from "./semantic-fact-types.js";
+import type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2 } from "./long-task-complete-delivery-evidence-types.js";
+export type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2, } from "./long-task-complete-delivery-evidence-types.js";
 interface EvidenceRecordBaseV2 {
     assertion_key: string;
     capability: EvidenceCapabilityV2;
@@ -272,5 +274,4 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
-export {};
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ActualProvenanceEvidenceV2 | ExternalSideEffectEvidenceV2 | DistinctIdentityEvidenceV2 | DataStateEvidenceV2 | PopulationCoverageEvidenceV2 | FailureInjectionEvidenceV2 | RecoveryEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;

package/dist/lib/long-task-evidence-v2.d.ts

@@ -1,5 +1,10 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, CounterfactualControlV2, GlobalCounterfactualControlV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2, observationAuthorityPaths?: readonly string[]): Promise<CheckExecutionResultV2>;
 export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[], baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
 export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2, baselineResults?: readonly CheckExecutionResultV2[], baselineExecutions?: ReadonlyMap<string, RawCommandExecutionV2>, executionUniverse?: readonly CompiledCheckV2[]): Promise<LongTaskFindingV2[]>;
+export declare function counterfactualExecutionMayOverlap(input: {
+    check: CompiledCheckV2;
+    control: CounterfactualControlV2 | GlobalCounterfactualControlV2;
+    protected_authority_paths?: readonly string[];
+}): boolean;
 export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[], allowedFanoutAssertions?: string[]): boolean;