project-tiny-context-harness 0.8.0 → 0.8.2

package/dist/lib/long-task-evidence-sensitivity-policy.js

@@ -1,18 +1,21 @@
 const NON_RESULT_SENSITIVITY_PREFIXES = [
     "requirement.",
     "control.",
+    "control_relation",
     "obligation.",
     "non_completing.",
     "forbidden_shortcut.",
 ];
 export function validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, report) {
     validateGlobalStructuredSensitivity(contract, globalChecks, report);
+    validateGlobalSemanticWitnesses(contract, globalChecks, report);
     const weakOutcomes = new Set(contract.risk.facts.weak_observability);
     for (const outcome of outcomes) {
         const population = outcome.acceptance.population;
         const counterfactualsByCheck = groupCounterfactuals(outcome);
         for (const check of outcome.acceptance.checks) {
             const counterfactuals = counterfactualsByCheck.get(check.key) ?? [];
+            validateBehavioralSemanticWitnesses(outcome.key, check, counterfactuals, report);
             if (check.evidence_adapter === "structured_json_v2") {
                 const assertionClaims = new Set(assertions(check).flatMap((assertion) => assertion.claims));
                 const populationClaims = new Set(population?.check_key === check.key ? population.claims : []);
@@ -35,6 +38,41 @@ export function validateClaimEvidenceSensitivity(contract, globalChecks, outcome
         }
     }
 }
+function validateGlobalSemanticWitnesses(contract, checks, report) {
+    for (const check of checks)
+        validateBehavioralSemanticWitnesses("GLOBAL", check, contract.global.acceptance.counterfactual_controls.filter((control) => control.check_key === check.key), report);
+}
+function validateBehavioralSemanticWitnesses(scope, check, counterfactuals, report) {
+    for (const assertion of assertions(check)) {
+        if (!assertion.claims.length || !isBehavioralAssertion(check, assertion))
+            continue;
+        const witnesses = counterfactuals.filter((control) => isNarrowSemanticMutation(control.mutation.type) &&
+            control.expected_assertion_failures.includes(assertion.key) &&
+            assertion.claims.every((claim) => control.claims.includes(claim)));
+        if (!witnesses.length) {
+            issue(report, `behavioral_semantic_counterfactual_required:${scope}:${check.key}:${assertion.key}`);
+            continue;
+        }
+        if (!witnesses.some((control) => control.preserved_assertions.some((reference) => isLivenessAssertion(check, reference))))
+            issue(report, `behavioral_counterfactual_liveness_witness_required:${scope}:${check.key}:${assertion.key}`);
+    }
+}
+function isNarrowSemanticMutation(type) {
+    return type === "replace_json_value" || type === "replace_text";
+}
+function isBehavioralAssertion(check, assertion) {
+    return !(check.proof_surface === "implementation_structure" &&
+        assertion.operator === "exists" &&
+        assertion.evidence_capabilities.every((capability) => capability === "presence"));
+}
+function isLivenessAssertion(check, reference) {
+    const assertion = check.positive_assertions.find((candidate) => candidate.key === reference);
+    return Boolean(assertion &&
+        !assertion.claims.length &&
+        assertion.operator === "equals" &&
+        assertion.expected === true &&
+        assertion.evidence_capabilities.includes("target_runtime"));
+}
 function validateGlobalStructuredSensitivity(contract, checks, report) {
     for (const check of checks) {
         if (check.evidence_adapter !== "structured_json_v2")

package/dist/lib/long-task-evidence-v2.js

@@ -5,6 +5,7 @@ import { executeCheckRunner } from "./long-task-check-runner.js";
 import { createCounterfactualSandbox } from "./long-task-counterfactual-sandbox.js";
 import { assertionFinding, checkFinding, classifyCheckStatus, evaluateAssertionResults, } from "./long-task-evidence-findings.js";
 import { classifyPlaywrightCounterfactual } from "./long-task-playwright-counterfactual-policy.js";
+import { applyNarrowSemanticMutation } from "./long-task-semantic-mutation.js";
 import { evaluateEvidenceCapabilities } from "./long-task-evidence-capability-policy.js";
 import { resolveInsideRepository } from "./long-task-workspace.js";
 export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
@@ -33,6 +34,7 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
                 assertion_key: result.key,
                 polarity: result.polarity,
                 proof_surface: check.proof_surface,
+                applicability_ref: result.applicability_ref ?? null,
             }))
             : [])
         : [];
@@ -45,6 +47,7 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
             assertion_key: null,
             polarity: "population",
             proof_surface: check.proof_surface,
+            applicability_ref: null,
         })));
     return {
         internal_id: check.internal_id,
@@ -141,9 +144,12 @@ async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
                 for (const target of control.mutation.paths)
                     await rm(resolveInsideRepository(root, target, "counterfactual.remove_paths"), { recursive: true, force: true });
             }
-            else {
+            else if (control.mutation.type === "replace_file") {
                 await copyFile(resolveInsideRepository(root, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
             }
+            else {
+                await applyNarrowSemanticMutation(root, control.mutation);
+            }
             const raw = await executeCheckRunner(check, root);
             const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome);
             const playwrightClassification = result.evidence_adapter === "playwright_json_v1"

package/dist/lib/long-task-final-integrity.d.ts

@@ -0,0 +1,16 @@
+import type { CompiledDeliveryContractV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+import { type ActiveAuthorityIdentityExpectation, type ActiveLongTaskAuthorityV3 } from "./long-task-state.js";
+import { currentGitState } from "./long-task-workspace.js";
+export interface FinalGateProtectedInputIdentity {
+    compiled_identity: string;
+    raw_contract_sha256: string;
+}
+export declare function captureFinalGateProtectedInputIdentity(repository: string, compiled: CompiledDeliveryContractV2): Promise<FinalGateProtectedInputIdentity>;
+export declare function finalGateIntegrityFindings(input: {
+    repository: string;
+    active: ActiveLongTaskAuthorityV3;
+    accepted_authority: ActiveAuthorityIdentityExpectation;
+    candidate: Awaited<ReturnType<typeof currentGitState>>;
+    workspace_identity_before: string;
+    protected_inputs_before: FinalGateProtectedInputIdentity;
+}): Promise<LongTaskFindingV2[]>;

package/dist/lib/long-task-final-integrity.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { activeAuthorityIdentityMatches, assertMatchingActiveBinding, loadActiveLongTaskAuthority, } from "./long-task-state.js";
+import { captureWorkspaceFingerprint, currentGitState, } from "./long-task-workspace.js";
+import { sha256Hex } from "./strict-codec.js";
+export async function captureFinalGateProtectedInputIdentity(repository, compiled) {
+    const file = await assertProtectedRepositoryFile(repository, path.join(repository, ...compiled.contract_file.split("/")), "final_gate_delivery_contract");
+    return {
+        compiled_identity: compiled.compiled_identity,
+        raw_contract_sha256: sha256Hex(await readFile(file)),
+    };
+}
+export async function finalGateIntegrityFindings(input) {
+    const findings = [];
+    const after = await captureWorkspaceFingerprint(input.repository);
+    const gitAfter = await currentGitState(input.repository);
+    if (after.identity !== input.workspace_identity_before ||
+        gitAfter.head !== input.candidate.head ||
+        gitAfter.tree !== input.candidate.tree ||
+        gitAfter.dirty.length)
+        findings.push(workspaceChangedFinding());
+    if (await activeAuthorityChanged(input))
+        findings.push(activeAuthorityChangedFinding());
+    findings.push(...(await protectedInputFindings(input)));
+    return findings;
+}
+async function activeAuthorityChanged(input) {
+    try {
+        const currentActive = (await loadActiveLongTaskAuthority(input.repository))
+            .authority;
+        return (!currentActive ||
+            !activeAuthorityIdentityMatches(currentActive, input.accepted_authority));
+    }
+    catch {
+        return true;
+    }
+}
+async function protectedInputFindings(input) {
+    try {
+        const refreshed = await compileDeliveryContract(input.active.workdir, input.repository, {
+            live_gate: true,
+            initial_task_base: input.active.initial_task_base,
+            authority_revision: input.active.authority_revision,
+            require_completion_gate: true,
+        });
+        await assertMatchingActiveBinding(refreshed);
+        const after = await captureFinalGateProtectedInputIdentity(input.repository, refreshed);
+        return after.compiled_identity !==
+            input.protected_inputs_before.compiled_identity ||
+            after.raw_contract_sha256 !==
+                input.protected_inputs_before.raw_contract_sha256
+            ? [
+                protectedInputsChangedFinding({
+                    before: input.protected_inputs_before,
+                    after,
+                }),
+            ]
+            : [];
+    }
+    catch (error) {
+        return [
+            protectedInputsChangedFinding({
+                before: input.protected_inputs_before,
+                after_error: error instanceof Error ? error.message : String(error),
+            }),
+        ];
+    }
+}
+function workspaceChangedFinding() {
+    return {
+        code: "workspace_changed_during_final_gate",
+        outcome_key: null,
+        check_key: null,
+        message: "The workspace changed while Live Final Gate was running.",
+        next_action: "Stop concurrent mutation and rerun the complete Live Final Gate.",
+    };
+}
+function activeAuthorityChangedFinding() {
+    return {
+        code: "active_authority_changed_during_final_gate",
+        outcome_key: null,
+        check_key: null,
+        message: "Active Authority changed while Live Final Gate was running.",
+        next_action: "Review the new Authority Revision and rerun the complete Live Final Gate.",
+    };
+}
+function protectedInputsChangedFinding(actual) {
+    return {
+        code: "protected_inputs_changed_during_final_gate",
+        outcome_key: null,
+        check_key: null,
+        message: "Protected Contract, Source, controlling Context, verifier/runner, verification-input or workdir input identity changed while Final Gate was running.",
+        actual,
+        next_action: "Stop concurrent protected-input mutation, review any required Authority Revision, and rerun the complete Final Gate.",
+    };
+}

package/dist/lib/long-task-final-v2.js

@@ -1,6 +1,7 @@
 import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
-import { activeAuthorityIdentityMatches, assertMatchingActiveBinding, loadActiveLongTaskAuthority, writeFinalReceipt, } from "./long-task-state.js";
-import { assertVerifierAuthorityCurrent } from "./long-task-freshness.js";
+import { captureFinalGateProtectedInputIdentity, finalGateIntegrityFindings, } from "./long-task-final-integrity.js";
+import { assertMatchingActiveBinding, loadActiveLongTaskAuthority, writeFinalReceipt, } from "./long-task-state.js";
+import { assertVerifierAuthorityCurrent, deliveryCompileFreshness, } from "./long-task-freshness.js";
 import { allCompiledChecks, runDeliveryChecks, } from "./long-task-verifier-v2.js";
 import { captureWorkspaceFingerprint, createWorkspaceSnapshot, currentGitState, repositoryRoot, } from "./long-task-workspace.js";
 export async function runDeliveryFinalGate(workdirInput) {
@@ -21,6 +22,11 @@ export async function runDeliveryFinalGate(workdirInput) {
     const candidate = await currentGitState(repository);
     if (candidate.dirty.length)
         throw new Error(`final_gate_requires_clean_candidate_commit:${candidate.dirty.join(",")}`);
+    const acceptedCompiled = active.authority_snapshot;
+    await assertMatchingActiveBinding(acceptedCompiled);
+    const staleAuthorityInputs = await deliveryCompileFreshness(acceptedCompiled);
+    if (staleAuthorityInputs.length)
+        throw new Error(`final_gate_protected_input_stale:${staleAuthorityInputs.join(",")}`);
     const compiled = await compileDeliveryContract(active.workdir, repository, {
         live_gate: true,
         initial_task_base: active.initial_task_base,
@@ -28,42 +34,19 @@ export async function runDeliveryFinalGate(workdirInput) {
         require_completion_gate: true,
     });
     await assertMatchingActiveBinding(compiled);
+    const protectedInputsBefore = await captureFinalGateProtectedInputIdentity(repository, compiled);
     const before = await captureWorkspaceFingerprint(repository);
     const snapshot = await createWorkspaceSnapshot(repository, active.workdir, `final-${compiled.task.id}`);
     try {
         const run = await runDeliveryChecks(compiled, snapshot, allCompiledChecks(compiled), true, true);
-        const after = await captureWorkspaceFingerprint(repository);
-        const gitAfter = await currentGitState(repository);
-        if (after.identity !== before.identity ||
-            gitAfter.head !== candidate.head ||
-            gitAfter.tree !== candidate.tree ||
-            gitAfter.dirty.length)
-            run.findings.push({
-                code: "workspace_changed_during_final_gate",
-                outcome_key: null,
-                check_key: null,
-                message: "The workspace changed while Live Final Gate was running.",
-                next_action: "Stop concurrent mutation and rerun the complete Live Final Gate.",
-            });
-        let activeAuthorityChanged = false;
-        try {
-            const currentActive = (await loadActiveLongTaskAuthority(repository))
-                .authority;
-            activeAuthorityChanged =
-                !currentActive ||
-                    !activeAuthorityIdentityMatches(currentActive, acceptedAuthority);
-        }
-        catch {
-            activeAuthorityChanged = true;
-        }
-        if (activeAuthorityChanged)
-            run.findings.push({
-                code: "active_authority_changed_during_final_gate",
-                outcome_key: null,
-                check_key: null,
-                message: "Active Authority changed while Live Final Gate was running.",
-                next_action: "Review the new Authority Revision and rerun the complete Live Final Gate.",
-            });
+        run.findings.push(...(await finalGateIntegrityFindings({
+            repository,
+            active,
+            accepted_authority: acceptedAuthority,
+            candidate,
+            workspace_identity_before: before.identity,
+            protected_inputs_before: protectedInputsBefore,
+        })));
         const outcomeResults = projectOutcomes(compiled.outcomes.map((outcome) => outcome.key), run.check_results, run.findings);
         const globalChecks = run.check_results.filter((check) => check.outcome_key === null);
         const globalHardFailure = globalChecks.some((check) => check.status !== "passed" && check.status !== "blocked_external");

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

@@ -1,22 +1,33 @@
 import { parseCheck } from "./long-task-check-shape.js";
 import { normalizeRepositoryFile } from "./long-task-paths.js";
 import { parseRequirements } from "./long-task-requirement-shape.js";
-import { array, boolean, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseKeyedStatements, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
+import { array, boolean, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseApplicableKeyedStatements, parseClaimApplicability, parseControlRelationClosure, parseControlRelations, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
 import { parseStrictYaml } from "./strict-codec.js";
 import { assertNoSemanticDriftMigration, semanticDriftOutcomeMigrationFields, } from "./long-task-semantic-drift-migration.js";
 import { parseSurfaceBindings } from "./long-task-ui-surface-shape.js";
 export function parseOutcome(value, label) {
     assertNoSemanticDriftMigration(semanticDriftOutcomeMigrationFields(value, label));
-    const row = object(value, label, ["key", "title", "stage", "product", "technical", "acceptance"], ["depends_on"]);
+    const row = object(value, label, [
+        "key",
+        "title",
+        "stage",
+        "applicability",
+        "product",
+        "technical",
+        "acceptance",
+    ], ["depends_on"]);
     const product = object(row.product, `${label}.product`, [
         "observable_result",
+        "result_applicability_refs",
         "success_path_required",
         "degradation_path_required",
         "owner",
+        "control_relation_closure",
     ], [
         "requirements",
         "owner_surfaces",
         "controls",
+        "control_relations",
         "surface_bindings",
         "non_completing_outcomes",
     ]);
@@ -36,8 +47,10 @@ export function parseOutcome(value, label) {
         depends_on: Object.hasOwn(row, "depends_on")
             ? strings(row.depends_on, `${label}.depends_on`).map((item, index) => key(item, `${label}.depends_on[${index}]`))
             : [],
+        applicability: parseClaimApplicability(row.applicability, `${label}.applicability`),
         product: {
             observable_result: string(product.observable_result, `${label}.product.observable_result`),
+            result_applicability_refs: strings(product.result_applicability_refs, `${label}.product.result_applicability_refs`).map((item, index) => key(item, `${label}.product.result_applicability_refs[${index}]`)),
             success_path_required: boolean(product.success_path_required, `${label}.product.success_path_required`),
             degradation_path_required: boolean(product.degradation_path_required, `${label}.product.degradation_path_required`),
             owner: parseOwner(product.owner, `${label}.product.owner`),
@@ -50,11 +63,15 @@ export function parseOutcome(value, label) {
             controls: Object.hasOwn(product, "controls")
                 ? parseControls(product.controls, `${label}.product.controls`)
                 : [],
+            control_relation_closure: parseControlRelationClosure(product.control_relation_closure, `${label}.product.control_relation_closure`),
+            control_relations: Object.hasOwn(product, "control_relations")
+                ? parseControlRelations(product.control_relations, `${label}.product.control_relations`)
+                : [],
             surface_bindings: Object.hasOwn(product, "surface_bindings")
                 ? parseSurfaceBindings(product.surface_bindings, `${label}.product.surface_bindings`)
                 : [],
             non_completing_outcomes: Object.hasOwn(product, "non_completing_outcomes")
-                ? parseKeyedStatements(product.non_completing_outcomes, `${label}.product.non_completing_outcomes`)
+                ? parseApplicableKeyedStatements(product.non_completing_outcomes, `${label}.product.non_completing_outcomes`)
                 : [],
         },
         technical: {
@@ -69,7 +86,7 @@ export function parseOutcome(value, label) {
                 ? repositoryPatterns(technical.forbidden_paths, `${label}.technical.forbidden_paths`)
                 : [],
             forbidden_shortcuts: Object.hasOwn(technical, "forbidden_shortcuts")
-                ? parseKeyedStatements(technical.forbidden_shortcuts, `${label}.technical.forbidden_shortcuts`)
+                ? parseApplicableKeyedStatements(technical.forbidden_shortcuts, `${label}.technical.forbidden_shortcuts`)
                 : [],
             bindings: Object.hasOwn(technical, "bindings")
                 ? parseBindings(technical.bindings, `${label}.technical.bindings`)
@@ -100,6 +117,7 @@ export function parseOutcomeFragment(raw, relative) {
         "title",
         "stage",
         "depends_on",
+        "applicability",
         "product",
         "technical",
         "acceptance",

package/dist/lib/long-task-playwright-case-evidence.d.ts

@@ -12,6 +12,7 @@ export interface PlaywrightCaseInstance {
     status: string;
     given_keys: string[];
     action_keys: string[];
+    attachment_names: string[];
 }
 export interface PlaywrightCase {
     id: string;
@@ -31,6 +32,7 @@ export interface PlaywrightCase {
     interrupted_instances: number;
     given_keys: string[];
     action_keys: string[];
+    attachment_names: string[];
 }
 export declare function collectCases(report: Record<string, unknown>, declaredIds: Set<string>): {
     cases: PlaywrightCaseInstance[];

package/dist/lib/long-task-playwright-case-evidence.js

@@ -75,6 +75,15 @@ function playwrightCase(id, test) {
         resultStatuses.length > 0 &&
         resultStatuses.at(-1) === "passed";
     const traces = results.map((result) => scenarioTrace(result));
+    const attachmentNames = [
+        ...new Set(results.flatMap((result) => Array.isArray(result.attachments)
+            ? result.attachments
+                .map(record)
+                .filter(Boolean)
+                .map((attachment) => attachment.name)
+                .filter((name) => typeof name === "string")
+            : [])),
+    ].sort();
     const givenKeys = traces[0]?.given_keys ?? [];
     const actionKeys = traces[0]?.action_keys ?? [];
     const traceConsistent = traces.every((trace) => same(trace.given_keys, givenKeys) && same(trace.action_keys, actionKeys));
@@ -91,6 +100,7 @@ function playwrightCase(id, test) {
         status,
         given_keys: traceConsistent ? givenKeys : [],
         action_keys: traceConsistent ? actionKeys : [],
+        attachment_names: attachmentNames,
     };
 }
 export function declaredCaseIds(check) {
@@ -99,8 +109,6 @@ export function declaredCaseIds(check) {
         ...check.positive_assertions,
         ...check.negative_assertions,
     ]) {
-        if (!assertion.claims.length)
-            continue;
         const match = /^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(assertion.observation);
         if (match)
             result.add(assertion.key);

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

@@ -5,3 +5,4 @@ export interface PlaywrightEvidence {
     error: string | null;
 }
 export declare function extractPlaywrightEvidence(check: CompiledCheckV2, report: Record<string, unknown>, exitCode: number): PlaywrightEvidence;
+export declare function designMethodAttachmentName(target: string, method: string, condition: string, kind: "record" | "observation"): string;

package/dist/lib/long-task-playwright-evidence.js

@@ -105,6 +105,32 @@ function evidenceRecordsForCases(check, cases) {
                     comparison_artifact_path: target.comparison_artifact_path,
                 });
         }
+        if (assertion?.evidence_capabilities.includes("design_method") &&
+            item.executed) {
+            for (const target of check.design_conformance_targets ?? []) {
+                const binding = target.verification_method_bindings.find((candidate) => candidate.assertion_ref === assertion.key);
+                if (!binding)
+                    continue;
+                const requiredAttachments = binding.evidence_artifacts.flatMap((artifact) => [
+                    designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "record"),
+                    designMethodAttachmentName(target.key, binding.method, artifact.condition_key, "observation"),
+                ]);
+                if (!requiredAttachments.every((name) => item.attachment_names.includes(name)))
+                    continue;
+                evidenceRecords.push({
+                    assertion_key: assertion.key,
+                    capability: "design_method",
+                    design_target_ref: target.key,
+                    target_ref: target.target_ref,
+                    method: binding.method,
+                    cells: binding.evidence_artifacts.map((artifact) => ({
+                        condition_key: artifact.condition_key,
+                        artifact_path: artifact.path,
+                        observation_artifact_path: artifact.observation_path,
+                    })),
+                });
+            }
+        }
     }
     return evidenceRecords;
 }
@@ -167,10 +193,16 @@ function aggregateCases(instances) {
                 rows.every((row) => same(row.action_keys, rows[0].action_keys))
                 ? rows[0].action_keys
                 : [],
+            attachment_names: rows.length === 0
+                ? []
+                : rows[0].attachment_names.filter((name) => rows.every((row) => row.attachment_names.includes(name))),
         };
     })
         .sort((left, right) => left.id.localeCompare(right.id));
 }
+export function designMethodAttachmentName(target, method, condition, kind) {
+    return `ty-context-design-method:${target}:${method}:${condition}:${kind}`;
+}
 function integer(value) {
     return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
 }

package/dist/lib/long-task-product-shape.d.ts

@@ -1,6 +1,8 @@
-import type { DeliveryControlV2, DeliveryObligationV2, DeliveryOwnerV2, KeyedPathV2, KeyedStatementV2 } from "./long-task-delivery-types.js";
+import type { DeliveryControlRelationClosureV2, DeliveryControlRelationV2, DeliveryControlV2, DeliveryObligationV2, DeliveryOwnerV2, KeyedPathV2, KeyedStatementV2 } from "./long-task-delivery-types.js";
 export declare function parseKeyedStatements(value: unknown, label: string): KeyedStatementV2[];
 export declare function parseKeyedPaths(value: unknown, label: string): KeyedPathV2[];
 export declare function parseControls(value: unknown, label: string): DeliveryControlV2[];
+export declare function parseControlRelations(value: unknown, label: string): DeliveryControlRelationV2[];
+export declare function parseControlRelationClosure(value: unknown, label: string): DeliveryControlRelationClosureV2;
 export declare function parseOwner(value: unknown, label: string): DeliveryOwnerV2;
 export declare function parseObligations(value: unknown, label: string): DeliveryObligationV2[];

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

@@ -1,5 +1,7 @@
+import { CONTROL_FIELD_NAMES } from "./long-task-control-fields.js";
+import { parseKeyRefs } from "./long-task-applicability-shape.js";
 import { parseRequiredProofSurfaces } from "./long-task-required-proof-surfaces.js";
-import { array, key, object, repositoryFiles, repositoryPattern, repositoryPatterns, string, text, } from "./long-task-shape-primitives.js";
+import { array, fail, key, literal, object, repositoryFiles, repositoryPattern, repositoryPatterns, string, text, } from "./long-task-shape-primitives.js";
 export function parseKeyedStatements(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
@@ -23,9 +25,10 @@ export function parseKeyedPaths(value, label) {
 export function parseControls(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "location"], [
+        const row = object(item, itemLabel, ["key", "field_coverage"], [
             "surface",
             "region",
+            "location",
             "control_type",
             "label_content",
             "user_task",
@@ -46,11 +49,11 @@ export function parseControls(value, label) {
             "feedback",
             "accessibility",
         ]);
-        return {
+        const control = {
             key: key(row.key, `${itemLabel}.key`),
             surface: optionalText(row, "surface", itemLabel),
             region: optionalText(row, "region", itemLabel),
-            location: string(row.location, `${itemLabel}.location`),
+            location: optionalText(row, "location", itemLabel),
             control_type: optionalText(row, "control_type", itemLabel),
             label_content: optionalText(row, "label_content", itemLabel),
             user_task: optionalText(row, "user_task", itemLabel),
@@ -70,9 +73,44 @@ export function parseControls(value, label) {
             permission: optionalText(row, "permission", itemLabel),
             feedback: optionalText(row, "feedback", itemLabel),
             accessibility: optionalText(row, "accessibility", itemLabel),
+            field_coverage: parseControlFieldCoverage(row.field_coverage, `${itemLabel}.field_coverage`),
+        };
+        validateControlFieldCoverage(control, itemLabel);
+        return control;
+    });
+}
+export function parseControlRelations(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "statement",
+            "control_refs",
+            "required_proof_surfaces",
+            "applicability_refs",
+        ]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            statement: string(row.statement, `${itemLabel}.statement`),
+            control_refs: parseKeyRefs(row.control_refs, `${itemLabel}.control_refs`),
+            required_proof_surfaces: parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`),
+            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
         };
     });
 }
+export function parseControlRelationClosure(value, label) {
+    const row = object(value, label, ["state", "statement"], ["applicability_refs"]);
+    const state = literal(row.state, ["specified", "not_applicable", "unresolved"], `${label}.state`);
+    return {
+        state,
+        statement: string(row.statement, `${label}.statement`),
+        applicability_refs: state === "unresolved"
+            ? Object.hasOwn(row, "applicability_refs")
+                ? parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`)
+                : []
+            : parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`),
+    };
+}
 export function parseOwner(value, label) {
     const row = object(value, label, ["label", "context_refs", "path_globs"]);
     return {
@@ -88,14 +126,72 @@ export function parseObligations(value, label) {
             "key",
             "statement",
             "required_proof_surfaces",
+            "applicability_refs",
         ]);
         return {
             key: key(row.key, `${itemLabel}.key`),
             statement: string(row.statement, `${itemLabel}.statement`),
             required_proof_surfaces: parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`),
+            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
         };
     });
 }
+function parseControlFieldCoverage(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["fields", "state"], ["statement", "applicability_refs"]);
+        const fields = array(row.fields, `${itemLabel}.fields`).map((field, fieldIndex) => literal(field, CONTROL_FIELD_NAMES, `${itemLabel}.fields[${fieldIndex}]`));
+        if (!fields.length)
+            fail(`${itemLabel}.fields`, "must not be empty");
+        const state = literal(row.state, ["specified", "not_applicable", "unresolved"], `${itemLabel}.state`);
+        if (state === "specified") {
+            if (Object.hasOwn(row, "statement"))
+                fail(`${itemLabel}.statement`, "forbidden for specified fields");
+            return {
+                fields,
+                state,
+                applicability_refs: parseRequiredApplicabilityRefs(row, itemLabel),
+            };
+        }
+        const statement = string(row.statement, `${itemLabel}.statement`);
+        if (state === "not_applicable")
+            return {
+                fields,
+                state,
+                statement,
+                applicability_refs: parseRequiredApplicabilityRefs(row, itemLabel),
+            };
+        if (Object.hasOwn(row, "applicability_refs") &&
+            array(row.applicability_refs, `${itemLabel}.applicability_refs`).length)
+            fail(`${itemLabel}.applicability_refs`, "must be empty while unresolved");
+        return { fields, state, statement, applicability_refs: [] };
+    });
+}
+function parseRequiredApplicabilityRefs(row, label) {
+    const refs = parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`);
+    if (!refs.length)
+        fail(`${label}.applicability_refs`, "must not be empty");
+    return refs;
+}
+function validateControlFieldCoverage(control, label) {
+    const owners = new Map();
+    for (const [index, entry] of control.field_coverage.entries()) {
+        for (const field of entry.fields) {
+            const previous = owners.get(field);
+            if (previous !== undefined)
+                fail(`${label}.field_coverage[${index}].fields`, `field ${field} already owned by entry ${previous}`);
+            owners.set(field, index);
+            const hasStatement = Boolean(control[field].trim());
+            if (entry.state === "specified" && !hasStatement)
+                fail(`${label}.${field}`, "must be non-empty when field state is specified");
+            if (entry.state !== "specified" && hasStatement)
+                fail(`${label}.${field}`, `must be empty when field state is ${entry.state}`);
+        }
+    }
+    const missing = CONTROL_FIELD_NAMES.filter((field) => !owners.has(field));
+    if (missing.length)
+        fail(`${label}.field_coverage`, `missing fields ${missing.join(",")}`);
+}
 function optionalText(row, field, label) {
     return Object.hasOwn(row, field) ? text(row[field], `${label}.${field}`) : "";
 }