project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,197 +0,0 @@
-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, 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}]`;
-        const row = object(item, itemLabel, ["key", "statement"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-        };
-    });
-}
-export function parseKeyedPaths(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "path"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            path: repositoryPattern(row.path, `${itemLabel}.path`),
-        };
-    });
-}
-export function parseControls(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "field_coverage"], [
-            "surface",
-            "region",
-            "location",
-            "control_type",
-            "label_content",
-            "user_task",
-            "visibility",
-            "availability",
-            "trigger",
-            "input",
-            "validation",
-            "default_value",
-            "interaction",
-            "navigation_result",
-            "loading_state",
-            "empty_state",
-            "success_state",
-            "failure_state",
-            "recovery",
-            "permission",
-            "feedback",
-            "accessibility",
-        ]);
-        const control = {
-            key: key(row.key, `${itemLabel}.key`),
-            surface: optionalText(row, "surface", itemLabel),
-            region: optionalText(row, "region", itemLabel),
-            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),
-            visibility: optionalText(row, "visibility", itemLabel),
-            availability: optionalText(row, "availability", itemLabel),
-            trigger: optionalText(row, "trigger", itemLabel),
-            input: optionalText(row, "input", itemLabel),
-            validation: optionalText(row, "validation", itemLabel),
-            default_value: optionalText(row, "default_value", itemLabel),
-            interaction: optionalText(row, "interaction", itemLabel),
-            navigation_result: optionalText(row, "navigation_result", itemLabel),
-            loading_state: optionalText(row, "loading_state", itemLabel),
-            empty_state: optionalText(row, "empty_state", itemLabel),
-            success_state: optionalText(row, "success_state", itemLabel),
-            failure_state: optionalText(row, "failure_state", itemLabel),
-            recovery: optionalText(row, "recovery", itemLabel),
-            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 {
-        label: string(row.label, `${label}.label`),
-        context_refs: repositoryFiles(row.context_refs, `${label}.context_refs`),
-        path_globs: repositoryPatterns(row.path_globs, `${label}.path_globs`),
-    };
-}
-export function parseObligations(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "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}`) : "";
-}

package/dist/lib/long-task-progress.d.ts

@@ -1,4 +0,0 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, ProgressRecordV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function createProgressRecord(compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, check: CompiledCheckV2, result: CheckExecutionResultV2): ProgressRecordV2;
-export declare function progressRecordFresh(record: ProgressRecordV2, compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, check: CompiledCheckV2): boolean;
-export declare function checkIdentity(check: CompiledCheckV2): string;

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

@@ -1,120 +0,0 @@
-import { outcomeAuthorityHash } from "./long-task-authority.js";
-import { contextAuthorityProjection } from "./long-task-context-authority.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function createProgressRecord(compiled, manifest, check, result) {
-    const outcome = check.outcome_key
-        ? (compiled.outcomes.find((item) => item.key === check.outcome_key) ?? null)
-        : null;
-    return {
-        schema_version: "long-task-progress-record-v2",
-        compiled_identity: compiled.compiled_identity,
-        outcome_authority_hash: progressAuthorityHash(compiled, outcome ?? null),
-        check_identity: checkIdentity(check),
-        check_internal_id: check.internal_id,
-        outcome_key: check.outcome_key,
-        check_key: check.key,
-        runner_verifier_identity: runnerVerifierIdentity(compiled, check),
-        relevant_context_identity: contextIdentity(compiled),
-        resolved_input_path_hashes: hashPatterns(manifest, check.input_paths),
-        binding_carrier_path_hashes: hashPatterns(manifest, progressBindingCarrierPatterns(compiled, check, outcome)),
-        dependency_interface_identities: dependencyInterfaceIdentities(compiled, manifest, outcome?.depends_on ?? []),
-        result: result.status,
-        check_result: result,
-        findings: result.findings,
-        completed_at: new Date().toISOString(),
-    };
-}
-export function progressRecordFresh(record, compiled, manifest, check) {
-    const outcome = check.outcome_key
-        ? (compiled.outcomes.find((item) => item.key === check.outcome_key) ?? null)
-        : null;
-    const expectedOutcomeAuthority = progressAuthorityHash(compiled, outcome ?? null);
-    return (record.check_internal_id === check.internal_id &&
-        record.check_identity === checkIdentity(check) &&
-        record.outcome_authority_hash === expectedOutcomeAuthority &&
-        record.runner_verifier_identity ===
-            runnerVerifierIdentity(compiled, check) &&
-        record.relevant_context_identity === contextIdentity(compiled) &&
-        same(record.resolved_input_path_hashes, hashPatterns(manifest, check.input_paths)) &&
-        same(record.binding_carrier_path_hashes, hashPatterns(manifest, progressBindingCarrierPatterns(compiled, check, outcome))) &&
-        same(record.dependency_interface_identities, dependencyInterfaceIdentities(compiled, manifest, outcome?.depends_on ?? [])));
-}
-function progressBindingCarrierPatterns(compiled, check, outcome) {
-    if (outcome)
-        return outcome.technical.bindings.flatMap((binding) => binding.carrier_paths);
-    const references = (compiled.global.acceptance.counterfactual_controls ?? [])
-        .filter((control) => control.check_key === check.key)
-        .map((control) => control.binding_ref);
-    return references.flatMap((reference) => {
-        const [outcomeKey, bindingKey] = reference.split(".");
-        return (compiled.outcomes
-            .find((item) => item.key === outcomeKey)
-            ?.technical.bindings.find((binding) => binding.key === bindingKey)
-            ?.carrier_paths ?? []);
-    });
-}
-function progressAuthorityHash(compiled, outcome) {
-    return sha256Hex(canonicalValueJson({
-        source: compiled.authority_hashes.source_authority_hash,
-        product: compiled.authority_hashes.product_authority_hash,
-        acceptance: compiled.authority_hashes.acceptance_authority_hash,
-        risk: compiled.authority_hashes.risk_authority_hash,
-        outcome: outcome ? outcomeAuthorityHash(outcome) : null,
-    }));
-}
-export function checkIdentity(check) {
-    return sha256Hex(canonicalValueJson({
-        internal_id: check.internal_id,
-        proof_surface: check.proof_surface,
-        evidence_adapter: check.evidence_adapter,
-        runner: check.runner.execution_identity,
-        raw_execution: check.raw_execution_identity,
-        verification_input_hashes: check.verification_input_hashes,
-        input_paths: check.input_paths,
-        expected_output_paths: check.expected_output_paths,
-        artifact_globs: check.artifact_globs,
-        positive_assertions: check.positive_assertions,
-        negative_assertions: check.negative_assertions,
-        journey_roles: check.journey_roles,
-        execution_target: check.execution_target,
-        execution_target_definition: check.execution_target_definition,
-        scenario: check.scenario,
-        environment_requirements: check.environment_requirements,
-        observation_authorities: check.observation_authorities,
-        process_runtime_closure: check.process_runtime_closure,
-    }));
-}
-function runnerVerifierIdentity(compiled, check) {
-    return sha256Hex(canonicalValueJson({
-        runner: check.raw_execution_identity,
-        verifier: compiled.verifier_identity.bundle_sha256,
-    }));
-}
-function contextIdentity(compiled) {
-    return sha256Hex(canonicalValueJson(contextAuthorityProjection(compiled.context_snapshot)));
-}
-function dependencyInterfaceIdentities(compiled, manifest, dependencies) {
-    const result = {};
-    for (const key of dependencies) {
-        const dependency = compiled.outcomes.find((outcome) => outcome.key === key);
-        if (!dependency)
-            continue;
-        result[key] = sha256Hex(canonicalValueJson({
-            authority: outcomeAuthorityHash(dependency),
-            carriers: hashPatterns(manifest, dependency.technical.bindings.flatMap((binding) => binding.carrier_paths)),
-        }));
-    }
-    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
-}
-function hashPatterns(manifest, patterns) {
-    const result = {};
-    for (const pattern of patterns)
-        for (const file of manifest.files)
-            if (matchesRepoPattern(file.path, pattern))
-                result[file.path] = file.sha256;
-    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
-}
-function same(left, right) {
-    return canonicalValueJson(left) === canonicalValueJson(right);
-}

package/dist/lib/long-task-proof-adequacy.d.ts

@@ -1,12 +0,0 @@
-import type { DeliveryContractV2, EvidenceCapabilityV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export { externalClaimCapabilityFloor } from "./long-task-proof-capability-floor.js";
-export type CheckCompletionRoleV2 = "semantic" | "diagnostic";
-export interface CheckProofAdequacyV2 {
-    completion_role: CheckCompletionRoleV2;
-    expected_authority_refs: Record<string, string>;
-    required_evidence_capabilities: Record<string, EvidenceCapabilityV2[]>;
-}
-export type ProofAdequacyByCheckV2 = Record<string, CheckProofAdequacyV2>;
-export declare function proofAdequacyCheckKey(outcomeKey: string | null, checkKey: string): string;
-export declare function validateLongTaskProofAdequacy(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expectationsByCheck: ReadonlyMap<string, SemanticFactExpectationV2[]>): ProofAdequacyByCheckV2;

package/dist/lib/long-task-proof-adequacy.js

@@ -1,57 +0,0 @@
-import { generateClaims, generateGlobalClaims, } from "./long-task-claim-definitions.js";
-import { assertionCapabilityFloor } from "./long-task-proof-capability-floor.js";
-import { claimSemanticCapabilityFloor } from "./long-task-claim-semantic-proof-floor.js";
-import { resolveExpectedAuthority } from "./long-task-expected-authority.js";
-import { validateSemanticFactProofFloors } from "./long-task-semantic-proof-adequacy.js";
-export { externalClaimCapabilityFloor } from "./long-task-proof-capability-floor.js";
-export function proofAdequacyCheckKey(outcomeKey, checkKey) {
-    return `${outcomeKey ?? "GLOBAL"}:${checkKey}`;
-}
-export function validateLongTaskProofAdequacy(contract, manifest, expectationsByCheck) {
-    validateSemanticFactProofFloors(manifest);
-    const result = {};
-    const globalClaims = new Map(generateGlobalClaims(contract.global).map((claim) => [
-        claim.local_key,
-        claim,
-    ]));
-    for (const check of contract.global.acceptance.checks)
-        result[proofAdequacyCheckKey(null, check.key)] = validateCheck(contract, null, check, globalClaims, manifest, expectationsByCheck.get(check.key) ?? []);
-    for (const outcome of contract.outcomes) {
-        const claims = new Map(generateClaims(outcome).map((claim) => [claim.local_key, claim]));
-        for (const check of outcome.acceptance.checks)
-            result[proofAdequacyCheckKey(outcome.key, check.key)] = validateCheck(contract, outcome.key, check, claims, manifest, expectationsByCheck.get(check.key) ?? []);
-    }
-    return result;
-}
-function validateCheck(contract, outcomeKey, check, claims, manifest, expectations) {
-    const assertions = [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ];
-    const claimBearing = assertions.filter((assertion) => assertion.claims.length);
-    const expectedAuthorityRefs = {};
-    const requiredCapabilities = {};
-    for (const assertion of claimBearing) {
-        const claimRef = assertion.claims[0];
-        const claim = claims.get(claimRef);
-        if (!claim)
-            fail("proof_adequacy_claim_unknown", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}:${claimRef}`);
-        expectedAuthorityRefs[assertion.key] = resolveExpectedAuthority(contract, outcomeKey, assertion, manifest, expectations);
-        const required = assertionCapabilityFloor(contract, outcomeKey, check, assertion, claim, expectations, claimSemanticCapabilityFloor(contract, manifest, outcomeKey, claimRef, assertion.applicability_ref ?? null, "kind" in claim ? claim.kind : undefined, "required_proof_surfaces" in claim ? claim.required_proof_surfaces : []));
-        requiredCapabilities[assertion.key] = [...required].sort();
-        const missing = [...required].filter((capability) => !assertion.evidence_capabilities.includes(capability));
-        if (missing.length)
-            fail("proof_adequacy_capability_missing", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}:${missing.sort().join(",")}`);
-        if (required.has("population_coverage") &&
-            assertion.operator !== "set_equals")
-            fail("population_coverage_set_equality_required", `${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}`);
-    }
-    return {
-        completion_role: claimBearing.length ? "semantic" : "diagnostic",
-        expected_authority_refs: expectedAuthorityRefs,
-        required_evidence_capabilities: requiredCapabilities,
-    };
-}
-function fail(code, detail) {
-    throw new Error(`delivery_contract_invalid:${code}:${detail}`);
-}

package/dist/lib/long-task-proof-capability-floor.d.ts

@@ -1,6 +0,0 @@
-import type { DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, EvidenceCapabilityV2, ProductClaimV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
-export declare function assertionCapabilityFloor(contract: DeliveryContractV2, outcomeKey: string | null, check: DeliveryCheckV2, assertion: DeliveryAssertionV2, claim: ProductClaimV2 | {
-    kind?: string;
-    local_key: string;
-}, expectations: SemanticFactExpectationV2[], semanticClaimFloor?: ReadonlySet<EvidenceCapabilityV2>): Set<EvidenceCapabilityV2>;
-export declare function externalClaimCapabilityFloor(contract: DeliveryContractV2, outcomeKey: string | null, localClaim: string, proofSurface: DeliveryCheckV2["proof_surface"], applicabilityRef: string | null, checkKey?: string | null): Set<EvidenceCapabilityV2>;

package/dist/lib/long-task-proof-capability-floor.js

@@ -1,137 +0,0 @@
-import { controlFieldFacts } from "./long-task-control-fields.js";
-const CONTROL_EXISTS_FIELDS = new Set([
-    "surface",
-    "region",
-    "location",
-    "control_type",
-    "label_content",
-    "visibility",
-]);
-const CONTROL_STATE_FIELDS = new Set([
-    "availability",
-    "default_value",
-    "loading",
-    "empty",
-    "failure",
-    "permission",
-    "feedback",
-    "accessibility",
-]);
-const CONTROL_PRODUCT_EFFECT_FIELDS = new Set([
-    "user_task",
-    "trigger",
-    "input",
-    "validation",
-    "interaction",
-    "navigation_result",
-    "success",
-    "recovery",
-]);
-export function assertionCapabilityFloor(contract, outcomeKey, check, assertion, claim, expectations, semanticClaimFloor = new Set()) {
-    const result = externalClaimCapabilityFloor(contract, outcomeKey, assertion.claims[0], check.proof_surface, assertion.applicability_ref ?? null, check.key);
-    if (assertion.operator === "exists")
-        result.add("presence");
-    if ("kind" in claim && claim.kind === "result")
-        result.add("target_runtime");
-    addControlCapabilityFloor(result, contract, outcomeKey, claim);
-    addProofSurfaceFloor(result, check.proof_surface);
-    if (check.journey_roles.includes("recovery")) {
-        result.add("failure_injection");
-        result.add("recovery");
-    }
-    const outcome = outcomeKey
-        ? contract.outcomes.find((item) => item.key === outcomeKey)
-        : null;
-    if (outcome?.acceptance.population?.check_key === check.key &&
-        outcome.acceptance.population.claims.includes(assertion.claims[0]))
-        result.add("population_coverage");
-    if (assertion.evidence_capabilities.includes("visual_render") ||
-        assertion.evidence_capabilities.includes("design_conformance")) {
-        result.add("visual_render");
-        result.add("design_conformance");
-    }
-    const semantic = expectations.find((item) => item.assertion_ref === assertion.key);
-    if (semantic)
-        for (const capability of semanticFactCapabilityFloor(semantic, contract))
-            result.add(capability);
-    for (const capability of semanticClaimFloor)
-        result.add(capability);
-    return result;
-}
-export function externalClaimCapabilityFloor(contract, outcomeKey, localClaim, proofSurface, applicabilityRef, checkKey = null) {
-    const result = new Set();
-    if (localClaim === "result")
-        result.add("target_runtime");
-    addExternalControlCapabilityFloor(result, contract, outcomeKey, localClaim);
-    addProofSurfaceFloor(result, proofSurface);
-    const profile = applicabilityRef
-        ? (outcomeKey
-            ? contract.outcomes.find((item) => item.key === outcomeKey)
-                ?.applicability
-            : contract.global.applicability)?.find((item) => item.key === applicabilityRef)
-        : null;
-    if (profile?.journey_role === "recovery") {
-        result.add("failure_injection");
-        result.add("recovery");
-    }
-    const outcome = outcomeKey
-        ? contract.outcomes.find((item) => item.key === outcomeKey)
-        : null;
-    if (outcome?.acceptance.population &&
-        (!checkKey || outcome.acceptance.population.check_key === checkKey) &&
-        outcome.acceptance.population.claims.includes(localClaim))
-        result.add("population_coverage");
-    return result;
-}
-function addControlCapabilityFloor(result, contract, outcomeKey, claim) {
-    if (!("kind" in claim) || claim.kind !== "control" || !outcomeKey)
-        return;
-    addSpecifiedControlFloor(result, contract, outcomeKey, claim.local_key);
-}
-function addExternalControlCapabilityFloor(result, contract, outcomeKey, localClaim) {
-    if (!localClaim.startsWith("control.") || !outcomeKey)
-        return;
-    addSpecifiedControlFloor(result, contract, outcomeKey, localClaim);
-}
-function addSpecifiedControlFloor(result, contract, outcomeKey, localClaim) {
-    const field = localClaim.split(".").at(-1);
-    if (!controlClaimSpecified(contract, outcomeKey, localClaim))
-        return;
-    if (CONTROL_EXISTS_FIELDS.has(field))
-        result.add("presence");
-    if (CONTROL_STATE_FIELDS.has(field)) {
-        result.add("interaction_trace");
-        result.add("state_delta");
-    }
-    if (field === "permission") {
-        result.add("input_variation");
-        result.add("distinct_identity");
-        result.add("data_state");
-        result.add("target_runtime");
-    }
-    if (CONTROL_PRODUCT_EFFECT_FIELDS.has(field)) {
-        result.add("interaction_trace");
-        result.add("input_variation");
-        result.add("state_delta");
-    }
-}
-function addProofSurfaceFloor(result, proofSurface) {
-    if (proofSurface === "implementation_structure")
-        result.add("presence");
-    if (proofSurface === "data_state")
-        result.add("data_state");
-    if (proofSurface === "population_coverage")
-        result.add("population_coverage");
-}
-function semanticFactCapabilityFloor(expectation, contract) {
-    const outcome = contract.outcomes.find((item) => item.key === expectation.outcome_ref);
-    const binding = outcome?.semantic_fact_bindings.proofs.find((item) => item.proof_ref === expectation.proof_ref);
-    return new Set(binding?.evidence_capabilities ?? []);
-}
-function controlClaimSpecified(contract, outcomeKey, localClaim) {
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    const [, controlKey, field] = localClaim.split(".");
-    const control = outcome.product.controls.find((item) => item.key === controlKey);
-    return Boolean(control &&
-        controlFieldFacts(control).some((item) => item.claim_field === field && item.state === "specified"));
-}

package/dist/lib/long-task-protected-files.d.ts

@@ -1 +0,0 @@
-export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

package/dist/lib/long-task-protected-files.js

@@ -1 +0,0 @@
-export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

package/dist/lib/long-task-repair-frontier-checks.d.ts

@@ -1,8 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, ProgressRecordV2, RepairFrontierCheckV1, RepairFrontierSessionV1, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function checkDependencyPatterns(compiled: CompiledDeliveryContractV2, check: CompiledCheckV2): string[];
-export declare function checkDependencyPatternsForBinding(check: CompiledCheckV2, bindingRef: string): string[];
-export declare function freshDiagnosticEvidence(compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, progress: Record<string, ProgressRecordV2>, selectedCheckRefs: Set<string>): Map<string, string>;
-export declare function rerunSessions(checks: RepairFrontierCheckV1[]): RepairFrontierSessionV1[];
-export declare function authorityPaths(compiled: CompiledDeliveryContractV2): string[];
-export declare function allChecks(compiled: CompiledDeliveryContractV2): CompiledCheckV2[];
-export declare function checkObligationRefs(check: CompiledCheckV2): string[];

package/dist/lib/long-task-repair-frontier-checks.js

@@ -1,93 +0,0 @@
-import { progressRecordFresh } from "./long-task-progress.js";
-import { checkRef, unique } from "./long-task-repair-frontier-utils.js";
-export function checkDependencyPatterns(compiled, check) {
-    const outcome = check.outcome_key
-        ? compiled.outcomes.find((item) => item.key === check.outcome_key)
-        : null;
-    const direct = [
-        ...check.input_paths,
-        ...check.verification_inputs,
-        ...check.expected_output_paths,
-        ...Object.keys(check.runner.frozen_files),
-        ...check.observation_authorities.flatMap((authority) => authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths)),
-    ];
-    if (outcome)
-        direct.push(...outcome.product.owner.path_globs, ...outcome.technical.expected_change_paths, ...outcome.technical.allowed_support_paths, ...outcome.technical.bindings.flatMap((binding) => binding.kind === "file" || binding.kind === "path_glob"
-            ? [binding.target, ...binding.carrier_paths]
-            : binding.carrier_paths));
-    else
-        for (const control of compiled.global.acceptance.counterfactual_controls) {
-            if (control.check_key !== check.key)
-                continue;
-            direct.push(...bindingPatterns(compiled, control.binding_ref));
-        }
-    return unique(direct);
-}
-export function checkDependencyPatternsForBinding(check, bindingRef) {
-    return unique(check.observation_authorities
-        .flatMap((authority) => authority.carrier_refs)
-        .filter((carrier) => carrier.binding_ref === bindingRef)
-        .flatMap((carrier) => carrier.carrier_paths));
-}
-export function freshDiagnosticEvidence(compiled, manifest, progress, selectedCheckRefs) {
-    const result = new Map();
-    for (const check of allChecks(compiled)) {
-        const record = progress[check.internal_id];
-        if (!record ||
-            selectedCheckRefs.has(checkRef(check)) ||
-            !progressRecordFresh(record, compiled, manifest, check))
-            continue;
-        result.set(checkRef(check), `progress:${checkRef(check)}:${record.result}:${record.completed_at}`);
-    }
-    return result;
-}
-export function rerunSessions(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const group = groups.get(check.raw_execution_identity);
-        if (group)
-            group.push(check);
-        else
-            groups.set(check.raw_execution_identity, [check]);
-    }
-    return [...groups.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([identity, rows]) => ({
-        raw_execution_identity: identity,
-        check_refs: unique(rows.map((row) => row.check_ref)),
-        obligation_refs: unique(rows.flatMap((row) => row.obligation_refs)),
-    }));
-}
-export function authorityPaths(compiled) {
-    return unique([
-        compiled.contract_file,
-        ...Object.keys(compiled.contract_files),
-        ...Object.keys(compiled.source_hashes),
-        ...compiled.context_snapshot.files,
-        ...compiled.task.source_paths,
-        compiled.semantic_fact_manifest.source_path,
-    ]);
-}
-export function allChecks(compiled) {
-    return [
-        ...compiled.global.acceptance.checks,
-        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-}
-export function checkObligationRefs(check) {
-    return unique([
-        ...check.semantic_fact_expectations.map((expectation) => expectation.proof_ref),
-        ...check.observation_authorities.map((authority) => authority.obligation_ref),
-    ]);
-}
-function bindingPatterns(compiled, bindingRef) {
-    const [outcomeKey, bindingKey] = bindingRef.split(".");
-    const binding = compiled.outcomes
-        .find((outcome) => outcome.key === outcomeKey)
-        ?.technical.bindings.find((candidate) => candidate.key === bindingKey);
-    if (!binding)
-        return [];
-    return binding.kind === "file" || binding.kind === "path_glob"
-        ? [binding.target, ...binding.carrier_paths]
-        : binding.carrier_paths;
-}

package/dist/lib/long-task-repair-frontier-groups.d.ts

@@ -1,2 +0,0 @@
-import type { LongTaskFindingV2, RepairFrontierCheckV1, RepairFrontierGroupV1 } from "./long-task-delivery-types.js";
-export declare function groupRepairFindings(findings: LongTaskFindingV2[], checks: RepairFrontierCheckV1[], stillValidByCheck: Map<string, string>): RepairFrontierGroupV1[];