project-tiny-context-harness 0.8.16 → 0.8.17

package/dist/lib/design-resource-implementation-feasibility-validation-support.d.ts

@@ -0,0 +1,10 @@
+import type { DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalSourceRecordV1 } from "./design-resource-implementation-feasibility-types.js";
+export declare function invalidFeasibility(code: string, detail: string): never;
+export declare function unique(values: string[], code: string, detail?: string): void;
+export declare function requireKnownRefs<T>(refs: string[], values: Map<string, T>, code: string, detail?: string): void;
+export declare function requireSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
+export declare function requireAtLeastOneSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
+export declare function assertSameSet(actual: string[], expected: string[], code: string): void;
+export declare function assertNoExactVisualValues(values: string[], detail: string): void;
+export declare function validateNoExactVisualValueCarriers(document: DesignResourceImplementationFeasibilityV1): void;
+export declare function cellPair(familyRef: string, profileRef: string): string;

package/dist/lib/design-resource-implementation-feasibility-validation-support.js

@@ -0,0 +1,75 @@
+const EXACT_VISUAL_VALUE_PATTERNS = [
+    /#[0-9a-f]{3,8}\b/iu,
+    /\b(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\s*\(/iu,
+    /\b\d+(?:\.\d+)?(?:px|rem|em|pt|pc|vh|vw|vmin|vmax|ch|ex|deg)\b/iu,
+    /\b(?:color|background|font(?:-family|-size|-weight)?|line-height|border-radius|radius|padding|margin|gap|width|height|opacity|duration|easing|shadow)\s*[:=]\s*\S+/iu,
+    /--[a-z0-9_-]+\s*:\s*\S+/iu,
+];
+const TIME_VALUE_PATTERN = /\b\d+(?:\.\d+)?(?:ms|s)\b/giu;
+const MOTION_TIME_CONTEXT = /\b(?:animation|transition|motion|duration|delay|easing|timeline|keyframes?|fade|spring|stagger|enter|exit|hover|press|ease(?:-in|-out|-in-out)?)\b/iu;
+const TECHNICAL_TIME_CONTEXT = /\b(?:build|compile|bundle|generation|ci|tests?|startup|initialization|latency|timeout|network|benchmark|runtime\s+cost|render\s+cost|benchmark\s+execution)\b/iu;
+const TIME_CONTEXT_RADIUS = 80;
+export function invalidFeasibility(code, detail) {
+    throw new Error(`design_resource_implementation_feasibility_invalid:${code}${detail ? `:${detail}` : ""}`);
+}
+export function unique(values, code, detail = "") {
+    if (new Set(values).size !== values.length)
+        invalidFeasibility(code, detail || values.join(","));
+}
+export function requireKnownRefs(refs, values, code, detail = "") {
+    for (const ref of refs)
+        if (!values.has(ref))
+            invalidFeasibility(code, detail ? `${detail}:${ref}` : ref);
+}
+export function requireSourceRole(refs, sources, role, code, detail) {
+    requireKnownRefs(refs, sources, code, detail);
+    for (const ref of refs)
+        if (!sources.get(ref).roles.includes(role))
+            invalidFeasibility(code, `${detail}:${ref}:${role}`);
+}
+export function requireAtLeastOneSourceRole(refs, sources, role, code, detail) {
+    if (!refs.some((ref) => sources.get(ref)?.roles.includes(role)))
+        invalidFeasibility(code, `${detail}:${role}`);
+}
+export function assertSameSet(actual, expected, code) {
+    const left = [...actual].sort(compareText);
+    const right = [...expected].sort(compareText);
+    if (left.length !== right.length ||
+        left.some((value, index) => value !== right[index]))
+        invalidFeasibility(code, `${left.join(",")}:${right.join(",")}`);
+}
+export function assertNoExactVisualValues(values, detail) {
+    for (const value of values)
+        if (EXACT_VISUAL_VALUE_PATTERNS.some((pattern) => pattern.test(value)) ||
+            hasForbiddenTimeValue(value))
+            invalidFeasibility("exact_visual_value_forbidden", detail);
+}
+function hasForbiddenTimeValue(value) {
+    for (const match of value.matchAll(TIME_VALUE_PATTERN)) {
+        const index = match.index;
+        const context = value.slice(Math.max(0, index - TIME_CONTEXT_RADIUS), Math.min(value.length, index + match[0].length + TIME_CONTEXT_RADIUS));
+        if (MOTION_TIME_CONTEXT.test(context))
+            return true;
+        if (!TECHNICAL_TIME_CONTEXT.test(context))
+            return true;
+    }
+    return false;
+}
+export function validateNoExactVisualValueCarriers(document) {
+    for (const observation of document.substrate_observations)
+        if (observation.reason !== null)
+            assertNoExactVisualValues([observation.reason], `substrate_observation:${observation.kind}:reason`);
+    for (const cell of document.component_family_cells)
+        for (const realization of cell.feasible_realizations) {
+            assertNoExactVisualValues(realization.observed_costs, `realization:${realization.key}:observed_costs`);
+            assertNoExactVisualValues(realization.observed_risks, `realization:${realization.key}:observed_risks`);
+        }
+    for (const blocker of document.blockers)
+        assertNoExactVisualValues([blocker.description], `blocker:${blocker.key}:description`);
+}
+export function cellPair(familyRef, profileRef) {
+    return `${familyRef}\0${profileRef}`;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/lib/design-resource-implementation-feasibility-validation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceTechnicalFeasibilityInputV1, LoadedDesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+export declare function readAndValidateDesignResourceImplementationFeasibility(repository: string, handoffPath: string, inputs: DesignResourceTechnicalFeasibilityInputV1[], targetModels: Map<string, DesignResourceImplementationFeasibilityTargetModel>, canonicalResourcePaths: Set<string>): Promise<LoadedDesignResourceImplementationFeasibilityV1[]>;

package/dist/lib/design-resource-implementation-feasibility-validation.js

@@ -0,0 +1,138 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceImplementationFeasibilityJson } from "./design-resource-implementation-feasibility-shape.js";
+import { loadDesignResourceFeasibilityDecisionSource, } from "./design-resource-implementation-feasibility-source-decision.js";
+import { validateFeasibilityDocument } from "./design-resource-implementation-feasibility-validation-document.js";
+import { invalidFeasibility, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+const FEASIBILITY_MAX_BYTES = 2_097_152;
+const TECHNICAL_SOURCE_MAX_BYTES = 16_777_216;
+export async function readAndValidateDesignResourceImplementationFeasibility(repository, handoffPath, inputs, targetModels, canonicalResourcePaths) {
+    unique(inputs.map((item) => item.key), "input_key_duplicate");
+    unique(inputs.map((item) => item.path), "input_path_duplicate");
+    unique(inputs.map((item) => item.target_ref), "input_target_duplicate");
+    for (const input of inputs)
+        if (!targetModels.has(input.target_ref))
+            invalidFeasibility("input_target_unknown", input.target_ref);
+    validateTargetInputCoverage(inputs, targetModels);
+    const loaded = [];
+    const sourcePathIdentities = new Map();
+    for (const input of inputs) {
+        const model = targetModels.get(input.target_ref);
+        if (!model)
+            invalidFeasibility("input_target_unknown", input.target_ref);
+        if (input.path === handoffPath)
+            invalidFeasibility("input_must_not_be_handoff", input.key);
+        if (canonicalResourcePaths.has(input.path))
+            invalidFeasibility("input_mixed_into_canonical_resources", input.path);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...input.path.split("/")), `design_resource_feasibility:${input.key}`);
+        const size = (await stat(file)).size;
+        if (size > FEASIBILITY_MAX_BYTES)
+            invalidFeasibility("input_byte_limit_exceeded", `${input.key}:bytes=${size}:limit=${FEASIBILITY_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== input.sha256)
+            invalidFeasibility("input_digest_mismatch", `${input.key}:${input.sha256}:${digest}`);
+        const content = bytes.toString("utf8");
+        if (!Buffer.from(content, "utf8").equals(bytes))
+            invalidFeasibility("input_utf8_invalid", input.key);
+        const document = parseDesignResourceImplementationFeasibilityJson(content);
+        if (document.key !== input.key)
+            invalidFeasibility("input_key_mismatch", `${input.key}:${document.key}`);
+        if (document.target_ref !== input.target_ref)
+            invalidFeasibility("input_target_mismatch", `${input.target_ref}:${document.target_ref}`);
+        const decisionSources = await validateTechnicalSourceRecords(repository, handoffPath, input.path, document.source_records, canonicalResourcePaths, sourcePathIdentities);
+        await validateFeasibilityDocument(repository, document, model, decisionSources);
+        loaded.push({
+            index: input,
+            document,
+            identity: {
+                key: input.key,
+                target_ref: input.target_ref,
+                path: input.path,
+                sha256: digest,
+                realization_mode: document.realization_mode,
+                component_family_cells: document.component_family_cells.length,
+                blockers: document.blockers.length,
+            },
+        });
+    }
+    return loaded;
+}
+function validateTargetInputCoverage(inputs, targetModels) {
+    if (!inputs.length)
+        return;
+    const indexedTargets = new Set(inputs.map((item) => item.target_ref));
+    for (const model of targetModels.values())
+        if (model.source_profile_kind !== "reference" &&
+            !indexedTargets.has(model.target_ref))
+            invalidFeasibility("implementation_target_input_missing", model.target_ref);
+}
+async function validateTechnicalSourceRecords(repository, handoffPath, inputPath, records, canonicalResourcePaths, sharedPathIdentities) {
+    const decisionSources = new Map();
+    unique(records.map((item) => item.key), "source_record_key_duplicate");
+    unique(records.map((item) => `${item.path}\0${item.locator.kind}\0${item.locator.value}`), "source_record_locator_duplicate");
+    for (const record of records) {
+        if (!record.roles.length)
+            invalidFeasibility("source_record_roles_required", record.key);
+        unique(record.roles, "source_record_role_duplicate", record.key);
+        if (record.path === handoffPath || record.path === inputPath)
+            invalidFeasibility("source_record_self_reference", `${record.key}:${record.path}`);
+        if (canonicalResourcePaths.has(record.path))
+            invalidFeasibility("technical_source_mixed_into_canonical_resources", record.path);
+        validateSharedSourceIdentity(record, sharedPathIdentities);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...record.path.split("/")), `design_resource_feasibility_source:${record.key}`);
+        const size = (await stat(file)).size;
+        if (size > TECHNICAL_SOURCE_MAX_BYTES)
+            invalidFeasibility("source_record_byte_limit_exceeded", `${record.key}:bytes=${size}:limit=${TECHNICAL_SOURCE_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== record.sha256)
+            invalidFeasibility("source_record_digest_mismatch", `${record.key}:${record.sha256}:${digest}`);
+        const decisionSource = validateSourceLocator(record, bytes);
+        if (decisionSource)
+            decisionSources.set(record.key, decisionSource);
+    }
+    return decisionSources;
+}
+function validateSharedSourceIdentity(record, sharedPathIdentities) {
+    const identity = `${record.media_type}\0${record.sha256}`;
+    const previous = sharedPathIdentities.get(record.path);
+    if (previous && previous !== identity)
+        invalidFeasibility("source_record_path_identity_conflict", record.path);
+    sharedPathIdentities.set(record.path, identity);
+}
+function validateSourceLocator(record, bytes) {
+    if (record.locator.kind === "whole_resource")
+        return null;
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        invalidFeasibility("source_record_utf8_invalid", record.key);
+    if (record.locator.kind === "source_item")
+        return loadDesignResourceFeasibilityDecisionSource(record, content);
+    if (record.locator.kind === "json_pointer") {
+        validateJsonPointer(record, content);
+        return null;
+    }
+    if (!content.includes(record.locator.value))
+        invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+    return null;
+}
+function validateJsonPointer(record, content) {
+    let current;
+    try {
+        current = JSON.parse(content);
+    }
+    catch {
+        invalidFeasibility("source_record_json_invalid", record.key);
+    }
+    for (const raw of record.locator.value.slice(1).split("/")) {
+        const segment = raw.replace(/~1/gu, "/").replace(/~0/gu, "~");
+        if (!current ||
+            typeof current !== "object" ||
+            !Object.hasOwn(current, segment))
+            invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+        current = current[segment];
+    }
+}

package/dist/lib/design-resource-symbolic-fact-shape.js

@@ -1,5 +1,6 @@
 import { parseDesignResourceHandoffResources } from "./design-resource-handoff-shape-structure.js";
 import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
 import { array, literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
 export { parseDesignResourceObservableRuleManifestJson, parseDesignResourceObservableRuleManifestShape, } from "./design-resource-symbolic-manifest-shape.js";
 export function parseDesignResourceSymbolicHandoffShape(value) {
@@ -14,13 +15,14 @@ export function parseDesignResourceSymbolicHandoffShape(value) {
         "targets",
         "coverage",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs"]);
     return {
         schema_version: literal(root.schema_version, ["design-resource-handoff-v2"], `${label}.schema_version`),
         representation: literal(root.representation, ["symbolic_rules_v2"], `${label}.representation`),
         intent: literal(root.intent, ["implementation_handoff"], `${label}.intent`),
         scope: parseScope(root.scope, label),
         provenance: parseProvenance(root.provenance, label),
+        technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? [], `${label}.technical_feasibility_inputs`),
         resources: parseDesignResourceHandoffResources(root.resources),
         targets: parseTargets(root.targets, label),
         coverage: parseCoverage(root.coverage, label),

package/dist/lib/design-resource-symbolic-fact-types.d.ts

@@ -3,6 +3,7 @@ import type { DesignResourceEnvironmentV1, DesignResourceFactLineageV1, DesignRe
 import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceSourceProfileKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 import type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationDisposition, SymbolicDenotationPredicate, SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
 import type { DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-noninterference-types.js";
+import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
 export type { DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceEquivalenceCaseV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofMethodV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicStaticDependencyNodeV2, DesignResourceSymbolicStaticDependencyRootV2, } from "./design-resource-symbolic-noninterference-types.js";
 export interface DesignResourceSymbolicPopulationV2 {
     key: string;
@@ -175,6 +176,7 @@ export interface DesignResourceHandoffV2 {
         model: string;
         design_system_id: string;
     };
+    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     targets: DesignResourceSymbolicHandoffTargetV2[];
     coverage: DesignResourceSymbolicHandoffCoverageV2[];
@@ -199,6 +201,9 @@ export interface DesignResourceHandoffPreflightV2 extends ParsedDesignResourceHa
     status: "ready";
     manifest: DesignResourceObservableRuleManifestV2;
     resource_hashes: Record<string, string>;
+    technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
+    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
+    limitations: string[];
     rule_projections: DesignResourceSymbolicRuleProjectionV2[];
     metrics: {
         semantic_obligations: number;

package/dist/lib/design-resource-symbolic-fact-validation.js

@@ -7,6 +7,8 @@ import { validateSymbolicCoverage } from "./design-resource-symbolic-region-vali
 import { assertSameSet, invalid, requireExactRefs, unique, } from "./design-resource-symbolic-validation-support.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
+import { createV2ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
 export { designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicDependencyEdge, designResourceSymbolicNoninterferenceProofDigest, designResourceSymbolicObligationKey, designResourceSymbolicRuleKey, } from "./design-resource-symbolic-validation-support.js";
 const V2_MANIFEST_MAX_BYTES = 8_388_608;
 export async function preflightParsedDesignResourceSymbolicHandoff(repository, parsed) {
@@ -37,12 +39,23 @@ export async function preflightParsedDesignResourceSymbolicHandoff(repository, p
         invalid("v2_manifest_identity_mismatch", `${manifest.scope_key}:${manifest.target_key}`);
     const validated = validateDesignResourceSymbolicManifest(manifest, parsed, resources, contents);
     validateSymbolicCoverage(parsed, manifest);
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map([
+        [
+            target.key,
+            createV2ImplementationFeasibilityTargetModel(target, manifest),
+        ],
+    ]), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         ...parsed,
         preflight_schema_version: "design-resource-handoff-preflight-v2",
         status: "ready",
         manifest,
         resource_hashes: resourceHashes,
+        technical_feasibility_documents: feasibility.map((item) => item.document),
+        technical_feasibility_identities: feasibility.map((item) => item.identity),
+        limitations: target.source_profile.kind !== "reference" && !feasibility.length
+            ? ["technical feasibility not declared"]
+            : [],
         rule_projections: validated.ruleProjections,
         metrics: validated.metrics,
     };

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

@@ -19,11 +19,14 @@ import { captureWorkspaceManifest, repoRelative, } from "./long-task-workspace.j
 export async function validateContractForActivation(options) {
     const { contract, repository, workdir, mode } = options;
     const diagnostics = options.diagnostics ?? [];
+    const structureOptions = {
+        allowDeferredDesignComponentBindingClosure: true,
+    };
     if (mode === "collect")
-        for (const error of deliveryContractStructureDiagnostics(contract))
+        for (const error of deliveryContractStructureDiagnostics(contract, structureOptions))
             addDiagnosticError(diagnostics, error);
     else
-        validateDeliveryContractStructure(contract);
+        validateDeliveryContractStructure(contract, structureOptions);
     const claims = await attempt(mode, diagnostics, () => compileProductClaimCoverage(contract));
     if (mode === "fail_fast") {
         const decisions = contract.source_claims
@@ -45,7 +48,7 @@ export async function validateContractForActivation(options) {
             : undefined);
         return items;
     });
-    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository));
+    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems ?? []));
     const risk = await attempt(mode, diagnostics, () => {
         const decision = classifyLongTaskRisk(contract);
         validateRiskProof(contract, decision);
@@ -83,11 +86,15 @@ export async function validateContractForActivation(options) {
     const outcomes = [];
     for (const outcome of contract.outcomes) {
         const checks = [];
+        const blockedDesignAssertionRefsByCheck = new Map();
         for (const check of outcome.acceptance.checks) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
+            const blockedDesignAssertionRefs = externallyBlockedDesignAssertionRefs(outcome, check, contract.global.acceptance.external_confirmations);
+            blockedDesignAssertionRefsByCheck.set(check.key, blockedDesignAssertionRefs);
+            const machineCheck = projectMachineCheck(check, blockedDesignAssertionRefs);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(machineCheck, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key, contract.global.acceptance.external_confirmations), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }
@@ -96,7 +103,12 @@ export async function validateContractForActivation(options) {
             internal_id: `OUT.${outcome.key}`,
             generated_claims: claims?.by_outcome[outcome.key] ?? [],
             risk_reasons: risk?.reasons_by_outcome[outcome.key] ?? [],
-            acceptance: { ...outcome.acceptance, checks },
+            acceptance: {
+                ...outcome.acceptance,
+                checks,
+                counterfactual_controls: outcome.acceptance.counterfactual_controls.map((control) => projectCounterfactualControl(control, outcome.acceptance.checks.find((check) => check.key === control.check_key), blockedDesignAssertionRefsByCheck.get(control.check_key) ??
+                    new Set())),
+            },
         });
     }
     const allChecks = [
@@ -130,9 +142,11 @@ export async function validateContractForActivation(options) {
         outcomes,
     };
 }
-function designTargetsForCheck(outcome, checkKey) {
+function designTargetsForCheck(outcome, checkKey, confirmations) {
     return (outcome.product.surface_bindings ?? []).flatMap((binding) => binding.design_targets
-        .filter((target) => target.conformance_check_ref === checkKey)
+        .filter((target) => target.conformance_check_ref === checkKey &&
+        !confirmations.some((confirmation) => confirmation.blocks_target &&
+            confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`))))
         .map((target) => ({
         ...target,
         surface_binding_ref: binding.key,
@@ -140,6 +154,62 @@ function designTargetsForCheck(outcome, checkKey) {
         target_ref: binding.target_ref,
     })));
 }
+function externallyBlockedDesignAssertionRefs(outcome, check, confirmations) {
+    const refs = new Set();
+    const impactedClaims = new Set();
+    for (const binding of outcome.product.surface_bindings ?? [])
+        for (const target of binding.design_targets) {
+            if (target.conformance_check_ref !== check.key)
+                continue;
+            const blocked = confirmations.some((confirmation) => confirmation.blocks_target &&
+                confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)));
+            if (!blocked)
+                continue;
+            for (const confirmation of confirmations)
+                if (confirmation.blocks_target &&
+                    confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)))
+                    for (const claimRef of confirmation.impact_claims)
+                        impactedClaims.add(claimRef);
+            refs.add(target.conformance_assertion_ref);
+            for (const method of target.verification_method_bindings)
+                refs.add(method.assertion_ref);
+            for (const method of target.symbolic_method_bindings ?? [])
+                refs.add(method.assertion_ref);
+            if (target.symbolic_certificate_binding)
+                refs.add(target.symbolic_certificate_binding.assertion_ref);
+        }
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ])
+        if (assertion.evidence_capabilities.includes("state_delta") &&
+            assertion.claims.length > 0 &&
+            assertion.claims.every((claimRef) => impactedClaims.has(`${outcome.key}.${claimRef}`)))
+            refs.add(assertion.key);
+    return refs;
+}
+function projectMachineCheck(check, externallyBlockedAssertionRefs) {
+    if (!externallyBlockedAssertionRefs.size)
+        return check;
+    return {
+        ...check,
+        positive_assertions: check.positive_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
+        negative_assertions: check.negative_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
+    };
+}
+function projectCounterfactualControl(control, check, externallyBlockedAssertionRefs) {
+    if (!check || !externallyBlockedAssertionRefs.size)
+        return control;
+    const externallyBlockedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => externallyBlockedAssertionRefs.has(assertion.key))
+        .flatMap((assertion) => assertion.claims));
+    return {
+        ...control,
+        claims: control.claims.filter((claimRef) => !externallyBlockedClaims.has(claimRef)),
+        expected_assertion_failures: control.expected_assertion_failures.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+        preserved_assertions: control.preserved_assertions.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+    };
+}
 async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
     try {
         return await action();