project-tiny-context-harness 0.7.3 → 0.7.5

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-claim-definitions.js

@@ -5,14 +5,28 @@ export function generateClaims(outcome) {
         claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces));
     for (const control of outcome.product.controls) {
         const fields = [
+            ["surface", control.surface],
+            ["region", control.region],
             ["location", control.location],
+            ["control_type", control.control_type],
+            ["label_content", control.label_content],
+            ["user_task", control.user_task],
+            ["visibility", control.visibility],
+            ["availability", control.availability],
             ["trigger", control.trigger],
             ["input", control.input],
+            ["validation", control.validation],
+            ["default_value", control.default_value],
+            ["interaction", control.interaction],
+            ["navigation_result", control.navigation_result],
             ["loading", control.loading_state],
             ["empty", control.empty_state],
             ["success", control.success_state],
             ["failure", control.failure_state],
+            ["recovery", control.recovery],
+            ["permission", control.permission],
             ["feedback", control.feedback],
+            ["accessibility", control.accessibility],
         ];
         for (const [field, value] of fields)
             if (value.trim())

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[];
@@ -98,14 +102,28 @@ export interface DeliveryCheckV2 {
 }
 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;
 }
 interface DeliveryRequirementV2 extends KeyedStatementV2 {
     required_proof_surfaces: ProofSurface[];
@@ -144,9 +162,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 +195,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[];

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

@@ -0,0 +1,231 @@
+export function decodeEvidenceCapabilityRecords(value) {
+    if (!Array.isArray(value))
+        throw invalidRecord("must_be_array");
+    return value.map((item, index) => decodeRecord(item, index));
+}
+function decodeRecord(value, index) {
+    const label = `evidence_records[${index}]`;
+    const row = record(value, label);
+    const assertionKey = key(row.assertion_key, `${label}.assertion_key`);
+    const capability = nonEmpty(row.capability, `${label}.capability`);
+    const base = { assertion_key: assertionKey };
+    switch (capability) {
+        case "interaction_trace":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "target_ref",
+                "given_keys",
+                "action_keys",
+            ]);
+            return {
+                ...base,
+                capability,
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                given_keys: keys(row.given_keys, `${label}.given_keys`),
+                action_keys: keys(row.action_keys, `${label}.action_keys`),
+            };
+        case "state_delta":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "before_sha256",
+                "after_sha256",
+                "changed_fields",
+            ]);
+            return {
+                ...base,
+                capability,
+                before_sha256: sha(row.before_sha256, `${label}.before_sha256`),
+                after_sha256: sha(row.after_sha256, `${label}.after_sha256`),
+                changed_fields: strings(row.changed_fields, `${label}.changed_fields`),
+            };
+        case "cross_surface_consistency":
+            exact(row, label, ["assertion_key", "capability", "surfaces"]);
+            return {
+                ...base,
+                capability,
+                surfaces: array(row.surfaces, `${label}.surfaces`).map((item, surfaceIndex) => {
+                    const surfaceLabel = `${label}.surfaces[${surfaceIndex}]`;
+                    const surface = record(item, surfaceLabel);
+                    exact(surface, surfaceLabel, [
+                        "surface_ref",
+                        "target_ref",
+                        "state_sha256",
+                    ]);
+                    return {
+                        surface_ref: key(surface.surface_ref, `${surfaceLabel}.surface_ref`),
+                        target_ref: key(surface.target_ref, `${surfaceLabel}.target_ref`),
+                        state_sha256: sha(surface.state_sha256, `${surfaceLabel}.state_sha256`),
+                    };
+                }),
+            };
+        case "durable_readback":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "write_session_id",
+                "read_session_id",
+                "written_sha256",
+                "read_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                write_session_id: nonEmpty(row.write_session_id, `${label}.write_session_id`),
+                read_session_id: nonEmpty(row.read_session_id, `${label}.read_session_id`),
+                written_sha256: sha(row.written_sha256, `${label}.written_sha256`),
+                read_sha256: sha(row.read_sha256, `${label}.read_sha256`),
+            };
+        case "boundary_invocation":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "boundary",
+                "invocation_id",
+                "request_sha256",
+                "observer_target_ref",
+            ]);
+            return {
+                ...base,
+                capability,
+                boundary: nonEmpty(row.boundary, `${label}.boundary`),
+                invocation_id: nonEmpty(row.invocation_id, `${label}.invocation_id`),
+                request_sha256: sha(row.request_sha256, `${label}.request_sha256`),
+                observer_target_ref: key(row.observer_target_ref, `${label}.observer_target_ref`),
+            };
+        case "external_side_effect":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "boundary",
+                "effect_id",
+                "effect_sha256",
+                "observer_target_ref",
+            ]);
+            return {
+                ...base,
+                capability,
+                boundary: nonEmpty(row.boundary, `${label}.boundary`),
+                effect_id: nonEmpty(row.effect_id, `${label}.effect_id`),
+                effect_sha256: sha(row.effect_sha256, `${label}.effect_sha256`),
+                observer_target_ref: key(row.observer_target_ref, `${label}.observer_target_ref`),
+            };
+        case "failure_injection":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "fault",
+                "failure_observed",
+                "recovery_state_sha256",
+            ]);
+            if (row.failure_observed !== true)
+                throw invalidRecord(`${label}.failure_observed`);
+            return {
+                ...base,
+                capability,
+                fault: nonEmpty(row.fault, `${label}.fault`),
+                failure_observed: true,
+                recovery_state_sha256: sha(row.recovery_state_sha256, `${label}.recovery_state_sha256`),
+            };
+        case "visual_render":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "artifact_path",
+                "artifact_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+                artifact_sha256: sha(row.artifact_sha256, `${label}.artifact_sha256`),
+            };
+        case "target_runtime":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "target_ref",
+                "root_entrypoint",
+                "session_id",
+                "cold_start",
+            ]);
+            if (typeof row.cold_start !== "boolean")
+                throw invalidRecord(`${label}.cold_start`);
+            return {
+                ...base,
+                capability,
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                root_entrypoint: nonEmpty(row.root_entrypoint, `${label}.root_entrypoint`),
+                session_id: nonEmpty(row.session_id, `${label}.session_id`),
+                cold_start: row.cold_start,
+            };
+        case "input_variation":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "cases",
+                "failure_case_observed",
+            ]);
+            if (typeof row.failure_case_observed !== "boolean")
+                throw invalidRecord(`${label}.failure_case_observed`);
+            return {
+                ...base,
+                capability,
+                cases: array(row.cases, `${label}.cases`).map((item, caseIndex) => {
+                    const caseLabel = `${label}.cases[${caseIndex}]`;
+                    const entry = record(item, caseLabel);
+                    exact(entry, caseLabel, ["input_sha256", "output_sha256"]);
+                    return {
+                        input_sha256: sha(entry.input_sha256, `${caseLabel}.input_sha256`),
+                        output_sha256: sha(entry.output_sha256, `${caseLabel}.output_sha256`),
+                    };
+                }),
+                failure_case_observed: row.failure_case_observed,
+            };
+        default:
+            throw invalidRecord(`${label}.capability_unsupported:${capability}`);
+    }
+}
+function invalidRecord(detail) {
+    return new Error(`check_evidence_records_invalid:${detail}`);
+}
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalidRecord(label);
+    return value;
+}
+function exact(row, label, fields) {
+    const allowed = new Set(fields);
+    if (fields.some((field) => !Object.hasOwn(row, field)) ||
+        Object.keys(row).some((field) => !allowed.has(field)))
+        throw invalidRecord(`${label}.shape`);
+}
+function array(value, label) {
+    if (!Array.isArray(value))
+        throw invalidRecord(label);
+    return value;
+}
+function nonEmpty(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw invalidRecord(label);
+    return value;
+}
+function key(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}
+function strings(value, label) {
+    return array(value, label).map((item, index) => nonEmpty(item, `${label}[${index}]`));
+}
+function keys(value, label) {
+    return array(value, label).map((item, index) => key(item, `${label}[${index}]`));
+}
+function sha(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^[a-f0-9]{64}$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}

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

@@ -0,0 +1,8 @@
+import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityRecordV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
+type Reporter = (message: string) => void;
+export declare function validateEvidenceCapabilityDeclarations(contract: DeliveryContractV2, report?: Reporter): void;
+export declare function evaluateEvidenceCapabilities(check: CompiledCheckV2, records: EvidenceCapabilityRecordV2[], artifactHashes: Record<string, string>): {
+    complete: Record<string, boolean>;
+    findings: LongTaskFindingV2[];
+};