project-tiny-context-harness 0.7.2 → 0.7.4

package/dist/lib/long-task-authority.js

@@ -20,9 +20,13 @@ export function computeAuthorityHashes(contract) {
         }),
         product_authority_hash: hash({
             goal: contract.task.goal,
+            target_profile: contract.task.target_profile,
+            execution_targets: contract.task.execution_targets,
+            stages: contract.stages,
             global: contract.global.product,
             outcomes: contract.outcomes.map((outcome) => ({
                 key: outcome.key,
+                stage: outcome.stage,
                 product: outcome.product,
             })),
         }),
@@ -51,6 +55,7 @@ export function computeAuthorityHashes(contract) {
 }
 export function outcomeAuthorityHash(outcome) {
     return hash({
+        stage: outcome.stage,
         product: outcome.product,
         acceptance: {
             checks: outcome.acceptance.checks.map(acceptanceCheck),
@@ -73,7 +78,7 @@ export function acceptanceSemanticsChanged(previous, next) {
 export function isMonotonicAcceptanceStrengthening(previous, next) {
     if (!acceptanceSemanticsChanged(previous, next))
         return false;
-    if (!subset(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
+    if (!same(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
         !subset(previous.global.acceptance.counterfactual_controls ?? [], next.global.acceptance.counterfactual_controls) ||
         !checksStrengthened(previous.global.acceptance.checks, next.global.acceptance.checks))
         return false;
@@ -119,8 +124,32 @@ function checksStrengthened(previous, next) {
         const nextCheck = nextChecks.get(previousCheck.key);
         if (!nextCheck ||
             previousCheck.proof_surface !== nextCheck.proof_surface ||
-            !subset(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
-            !subset(previousCheck.negative_assertions, nextCheck.negative_assertions))
+            !same(previousCheck.execution_target, nextCheck.execution_target) ||
+            !subset(previousCheck.journey_roles, nextCheck.journey_roles) ||
+            !subset(previousCheck.scenario.given, nextCheck.scenario.given) ||
+            !subset(previousCheck.scenario.when, nextCheck.scenario.when) ||
+            !subset(previousCheck.verification_inputs, nextCheck.verification_inputs) ||
+            !subset(previousCheck.input_paths, nextCheck.input_paths) ||
+            !subset(previousCheck.expected_output_paths, nextCheck.expected_output_paths) ||
+            !subset(previousCheck.artifact_globs, nextCheck.artifact_globs) ||
+            !subset(previousCheck.environment_requirements, nextCheck.environment_requirements) ||
+            !assertionsStrengthened(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
+            !assertionsStrengthened(previousCheck.negative_assertions, nextCheck.negative_assertions))
+            return false;
+    }
+    return true;
+}
+function assertionsStrengthened(previous, next) {
+    const nextAssertions = new Map(next.map((assertion) => [assertion.key, assertion]));
+    for (const previousAssertion of previous) {
+        const nextAssertion = nextAssertions.get(previousAssertion.key);
+        if (!nextAssertion ||
+            previousAssertion.criterion !== nextAssertion.criterion ||
+            !same(previousAssertion.claims, nextAssertion.claims) ||
+            previousAssertion.observation !== nextAssertion.observation ||
+            previousAssertion.operator !== nextAssertion.operator ||
+            !same(previousAssertion.expected, nextAssertion.expected) ||
+            !subset(previousAssertion.evidence_capabilities, nextAssertion.evidence_capabilities))
             return false;
     }
     return true;

package/dist/lib/long-task-check-evidence-decoder.d.ts

@@ -1,3 +1,3 @@
 import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-export declare function decodeCheckEvidence(check: CompiledCheckV2, exitCode: number, stdout: Buffer, stderr: Buffer): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;
-export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;
+export declare function decodeCheckEvidence(check: CompiledCheckV2, exitCode: number, stdout: Buffer, stderr: Buffer): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "evidence_records" | "error">;
+export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "evidence_records" | "error">;

package/dist/lib/long-task-check-evidence-decoder.js

@@ -1,4 +1,5 @@
 import { extractPlaywrightEvidence } from "./long-task-playwright-evidence.js";
+import { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-policy.js";
 export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
     if (check.runner.type === "playwright_test")
         return decodePlaywright(check, exitCode, stdout, stderr);
@@ -9,13 +10,15 @@ export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
         .filter(Boolean);
     try {
         const payload = JSON.parse(lines.at(-1) ?? "");
-        if (payload.schema_version !== "long-task-check-result-v2")
+        if (payload.schema_version !== "long-task-check-result-v2" &&
+            payload.schema_version !== "long-task-check-result-v3")
             return invalidEvidence(exitCode, "check_evidence_schema_invalid");
         if (payload.execution_status === "blocked_external")
             return {
                 execution_status: "blocked_external",
                 exit_code: exitCode,
                 observations: {},
+                evidence_records: [],
                 error: `blocked_external:${String(payload.reason ?? "unspecified")}`,
             };
         if (payload.execution_status !== "completed")
@@ -24,10 +27,14 @@ export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
             typeof payload.observations !== "object" ||
             Array.isArray(payload.observations))
             return invalidEvidence(exitCode, "check_evidence_observations_invalid");
+        const evidenceRecords = payload.schema_version === "long-task-check-result-v3"
+            ? decodeEvidenceCapabilityRecords(payload.evidence_records)
+            : [];
         return {
             execution_status: "completed",
             exit_code: exitCode,
             observations: payload.observations,
+            evidence_records: evidenceRecords,
             error: null,
         };
     }
@@ -40,6 +47,7 @@ export function invalidEvidence(exitCode, error) {
         execution_status: "invalid_evidence",
         exit_code: exitCode,
         observations: {},
+        evidence_records: [],
         error,
     };
 }
@@ -53,6 +61,7 @@ function decodePlaywright(check, exitCode, stdout, stderr) {
             execution_status: "completed",
             exit_code: exitCode,
             observations: extracted.observations,
+            evidence_records: extracted.evidence_records,
             error: null,
         };
     }
@@ -64,6 +73,7 @@ function decodePlaywright(check, exitCode, stdout, stderr) {
                 execution_status: "infrastructure_error",
                 exit_code: exitCode,
                 observations: {},
+                evidence_records: [],
                 error: `playwright_startup_failed:${message(error)}`,
             };
         return invalidEvidence(exitCode, `playwright_report_invalid:${message(error)}`);

package/dist/lib/long-task-check-execution-policy.d.ts

@@ -2,6 +2,9 @@ import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
 export type CheckExecutionInputPolicy = "raw_execution" | "raw_execution_via_runner_freeze" | "per_check_evidence" | "progress_scope" | "final_gate_evidence" | "authority_metadata";
 export declare const CHECK_EXECUTION_INPUT_POLICY: {
     key: "authority_metadata";
+    journey_roles: "authority_metadata";
+    execution_target: "raw_execution";
+    scenario: "per_check_evidence";
     proof_surface: "authority_metadata";
     runner: "raw_execution";
     verification_inputs: "raw_execution_via_runner_freeze";

package/dist/lib/long-task-check-execution-policy.js

@@ -1,6 +1,9 @@
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export const CHECK_EXECUTION_INPUT_POLICY = {
     key: "authority_metadata",
+    journey_roles: "authority_metadata",
+    execution_target: "raw_execution",
+    scenario: "per_check_evidence",
     proof_surface: "authority_metadata",
     runner: "raw_execution",
     verification_inputs: "raw_execution_via_runner_freeze",
@@ -14,6 +17,8 @@ export const CHECK_EXECUTION_INPUT_POLICY = {
 export function rawExecutionInputProjection(check) {
     const projection = {};
     projection.evidence_adapter = check.evidence_adapter;
+    projection.execution_target_definition = check.execution_target_definition;
+    projection.known_execution_targets = check.known_execution_targets;
     for (const field of Object.keys(CHECK_EXECUTION_INPUT_POLICY)) {
         const policy = CHECK_EXECUTION_INPUT_POLICY[field];
         if (policy === "raw_execution") {

package/dist/lib/long-task-check-runner.js

@@ -17,6 +17,7 @@ export async function executeCheckRunner(check, snapshotRoot) {
             execution_status: "blocked_external",
             exit_code: -1,
             observations: {},
+            evidence_records: [],
             stdout_sha256: sha256Hex(""),
             stderr_sha256: sha256Hex(""),
             attempts: 0,
@@ -55,6 +56,7 @@ export async function executeCheckRunner(check, snapshotRoot) {
                 execution_status: "infrastructure_error",
                 exit_code: -1,
                 observations: {},
+                evidence_records: [],
                 stdout_sha256: sha256Hex(""),
                 stderr_sha256: sha256Hex(reason),
                 attempts: attempt,

package/dist/lib/long-task-check-shape.js

@@ -1,6 +1,14 @@
-import { array, fail, key, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
+import { array, EVIDENCE_CAPABILITIES, fail, key, JOURNEY_ROLES, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
 export function parseCheck(value, label) {
-    const row = object(value, label, ["key", "proof_surface", "runner", "verification_inputs"], [
+    const row = object(value, label, [
+        "key",
+        "journey_roles",
+        "execution_target",
+        "scenario",
+        "proof_surface",
+        "runner",
+        "verification_inputs",
+    ], [
         "input_paths",
         "expected_output_paths",
         "artifact_globs",
@@ -8,8 +16,19 @@ export function parseCheck(value, label) {
         "negative_assertions",
         "environment_requirements",
     ]);
+    const executionTarget = object(row.execution_target, `${label}.execution_target`, ["target_ref", "entrypoint"]);
+    const scenario = object(row.scenario, `${label}.scenario`, ["given", "when"]);
     return {
         key: key(row.key, `${label}.key`),
+        journey_roles: array(row.journey_roles, `${label}.journey_roles`).map((item, index) => literal(item, JOURNEY_ROLES, `${label}.journey_roles[${index}]`)),
+        execution_target: {
+            target_ref: key(executionTarget.target_ref, `${label}.execution_target.target_ref`),
+            entrypoint: literal(executionTarget.entrypoint, ["root", "internal"], `${label}.execution_target.entrypoint`),
+        },
+        scenario: {
+            given: parseScenarioSteps(scenario.given, `${label}.scenario.given`),
+            when: parseScenarioSteps(scenario.when, `${label}.scenario.when`),
+        },
         proof_surface: literal(row.proof_surface, PROOF_SURFACES, `${label}.proof_surface`),
         runner: parseRunner(row.runner, `${label}.runner`),
         verification_inputs: repositoryPatterns(row.verification_inputs, `${label}.verification_inputs`),
@@ -70,7 +89,7 @@ function parseRunner(value, label) {
 function parseAssertions(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "claims", "observation", "operator"], ["criterion", "expected"]);
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "expected"]);
         const operator = literal(row.operator, [
             "equals",
             "not_equals",
@@ -103,6 +122,7 @@ function parseAssertions(value, label) {
                 : {}),
             claims: strings(row.claims, `${itemLabel}.claims`),
             observation: string(row.observation, `${itemLabel}.observation`),
+            evidence_capabilities: array(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
             operator,
         };
         return isBinaryAssertionOperator(operator)
@@ -113,6 +133,16 @@ function parseAssertions(value, label) {
             };
     });
 }
+function parseScenarioSteps(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["key", "statement"]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            statement: string(row.statement, `${itemLabel}.statement`),
+        };
+    });
+}
 function isBinaryAssertionOperator(operator) {
     return !["exists", "truthy", "falsy"].includes(operator);
 }

package/dist/lib/long-task-conformance-policy.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledCheckV2, DeliveryContractV2, EffectiveRiskLevel } from "./long-task-delivery-types.js";
+type Reporter = (message: string) => void;
+export declare function semanticConformanceRequired(contract: DeliveryContractV2, _effectiveRisk?: EffectiveRiskLevel): boolean;
+export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter): void;
+export {};

package/dist/lib/long-task-conformance-policy.js

@@ -0,0 +1,35 @@
+export function semanticConformanceRequired(contract, _effectiveRisk) {
+    const productFamilies = new Set(contract.task.execution_targets
+        .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
+        .map((target) => target.runtime_family));
+    return (contract.risk.facts.weak_observability.length > 0 &&
+        (productFamilies.size > 1 || contract.stages.length > 1));
+}
+export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
+    const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
+    if (semanticConformanceRequired(contract, effectiveRisk) &&
+        !declared.length) {
+        issue(report, "semantic_conformance_check_required", contract.task.id);
+        return;
+    }
+    for (const check of declared) {
+        if (check.runner.effect !== "read_only")
+            issue(report, "conformance_check_must_be_read_only", check.key);
+        if (![...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime")))
+            issue(report, "conformance_target_runtime_evidence_required", check.key);
+        const compiled = compiledChecks.find((candidate) => candidate.outcome_key === null && candidate.key === check.key);
+        if (!compiled)
+            continue;
+        if (compiledChecks.some((candidate) => candidate.internal_id !== compiled.internal_id &&
+            candidate.outcome_key !== null &&
+            candidate.raw_execution_identity === compiled.raw_execution_identity))
+            issue(report, "conformance_raw_execution_must_be_independent", check.key);
+    }
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}

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

@@ -1,5 +1,6 @@
 import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
 import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
+import type { CheckExecutionTargetV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -28,10 +29,6 @@ export interface SourceClaimV2 {
     statement: string;
     disposition: SourceClaimDispositionV2;
 }
-export interface KeyedStatementV2 {
-    key: string;
-    statement: string;
-}
 export interface KeyedPathV2 {
     key: string;
     path: string;
@@ -40,6 +37,9 @@ 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";
@@ -51,6 +51,7 @@ interface DeliveryAssertionBaseV2 {
     criterion?: string;
     claims: string[];
     observation: string;
+    evidence_capabilities: EvidenceCapabilityV2[];
 }
 export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
     operator: PresenceOrUnaryAssertionOperator;
@@ -86,6 +87,9 @@ export type EnvironmentRequirementV2 = {
 };
 export interface DeliveryCheckV2 {
     key: string;
+    journey_roles: DeliveryJourneyRoleV2[];
+    execution_target: CheckExecutionTargetV2;
+    scenario: DeliveryScenarioV2;
     proof_surface: ProofSurface;
     runner: DeliveryRunnerV2;
     verification_inputs: string[];
@@ -144,9 +148,12 @@ export interface PopulationRequirementV2 {
 export interface DeliveryOutcomeV2 {
     key: string;
     title: string;
+    stage: string;
     depends_on: string[];
     product: {
         observable_result: string;
+        success_path_required: boolean;
+        degradation_path_required: boolean;
         owner: DeliveryOwnerV2;
         requirements: DeliveryRequirementV2[];
         owner_surfaces: string[];
@@ -174,11 +181,14 @@ export interface DeliveryContractV2 {
         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;

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

@@ -114,6 +114,7 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         task: contract.task,
         risk: contract.risk,
         source_claims: contract.source_claims,
+        stages: contract.stages,
         global: {
             product: contract.global.product,
             technical: contract.global.technical,

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

@@ -5,8 +5,9 @@ import { validateDeliveryContractStructure } from "./long-task-delivery-validati
 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, parseTask } from "./long-task-root-shape.js";
+import { parseGlobal, parseRisk, parseStages, parseTask, } from "./long-task-root-shape.js";
 import { repositoryRoot } from "./long-task-workspace.js";
+import { assertNoSemanticDriftMigration, semanticDriftMigrationFields, } from "./long-task-semantic-drift-migration.js";
 export const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
 export async function parseDeliveryContract(workdir) {
     return (await parseDeliveryContractBundle(workdir)).contract;
@@ -75,7 +76,8 @@ function parseRoot(raw, bundle) {
         decoded.schema_version ===
             "long-task-delivery-v1")
         throw new Error("long_task_delivery_v1_retired_use_v2");
-    return object(decoded, "$", ["schema_version", "task", "source_claims", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
+    assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
+    return object(decoded, "$", ["schema_version", "task", "source_claims", "stages", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
 }
 function parseContractRoot(root, outcomes) {
     literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");
@@ -83,6 +85,7 @@ function parseContractRoot(root, outcomes) {
         schema_version: "long-task-delivery-v2",
         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-types.d.ts

@@ -2,7 +2,9 @@ export * from "./long-task-contract-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-evidence-capability-types.js";
 export * from "./long-task-risk-types.js";
 export * from "./long-task-runtime-types.js";
+export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";

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

@@ -2,7 +2,9 @@ export * from "./long-task-contract-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-evidence-capability-types.js";
 export * from "./long-task-risk-types.js";
 export * from "./long-task-runtime-types.js";
+export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";

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

@@ -4,6 +4,9 @@ import { proveRepositoryPatternSubset } from "./long-task-paths.js";
 import { validateSourceClaimMappings } from "./long-task-source-claim-validation.js";
 import { validateDeclaredCheckSafety } from "./long-task-claim-proof-policy.js";
 import { validateEvidenceAdapterCompatibility } from "./long-task-evidence-adapter-policy.js";
+import { validateEvidenceCapabilityDeclarations } from "./long-task-evidence-capability-policy.js";
+import { validateDeliveryStages } from "./long-task-stage-policy.js";
+import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "./long-task-target-policy.js";
 export function validateDeliveryContractStructure(contract) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
@@ -15,12 +18,19 @@ export function validateDeliveryContractStructure(contract) {
     });
     validateSourceClaimMappings(contract, claims);
     assertCompiledClaimsCovered(claims);
+    validateDeliveryStages(contract);
+    validateExecutionTargets(contract);
+    validateEvidenceCapabilityDeclarations(contract);
+    validateExternalConfirmationImpacts(contract, claims);
 }
 export function deliveryContractStructureDiagnostics(contract) {
     const diagnostics = [];
     const report = (message) => diagnostics.push(message);
     validateUniqueKeys(contract, report);
     validateDependencies(contract, report);
+    validateDeliveryStages(contract, report);
+    validateExecutionTargets(contract, report);
+    validateEvidenceCapabilityDeclarations(contract, report);
     validateOwnerAndBindings(contract, report);
     validateDeclaredCheckSafety(contract, report);
     validateEvidenceAdapters(contract, report);
@@ -30,6 +40,7 @@ export function deliveryContractStructureDiagnostics(contract) {
     });
     if (claims) {
         validateSourceClaimMappings(contract, claims, report);
+        validateExternalConfirmationImpacts(contract, claims, report);
         capture(diagnostics, () => assertCompiledClaimsCovered(claims));
     }
     return [...new Set(diagnostics)];

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

@@ -0,0 +1,2 @@
+import type { EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+export declare function decodeEvidenceCapabilityRecords(value: unknown): EvidenceCapabilityRecordV2[];