project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,479 +0,0 @@
-import { JSON_POINTER_EXACT_METHODS, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
-import { classifyMachineObservationCarrierRoleConflict } from "./long-task-admitted-observation.js";
-import { designGroundObligationRef } from "./long-task-design-obligation.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { classifyRepositoryPatternOverlap, normalizeRepositoryFile, } from "./long-task-paths.js";
-const PROCESS_DERIVED_CAPABILITIES = new Set([
-    "presence",
-    "target_runtime",
-]);
-const PROCESS_CAPABILITIES_REQUIRING_A_SEPARATE_PACKAGE_DERIVATION = new Set([
-    "interaction_trace",
-    "state_delta",
-    "design_conformance",
-]);
-const STATIC_DERIVED_CAPABILITIES = new Set(["presence"]);
-export function compileObservationAuthorityPlan(input) {
-    const assertions = new Map([
-        ...input.check.positive_assertions,
-        ...input.check.negative_assertions,
-    ].map((assertion) => [assertion.key, assertion]));
-    const candidates = [];
-    const factBoundAssertions = new Set();
-    for (const expectation of input.semantic_fact_expectations) {
-        if (expectation.observer_refs.length)
-            fail("semantic_fact_machine_observer_not_admitted", `${expectation.proof_ref}:observer_results_package_channel_unavailable:${expectation.observer_refs.join(",")}`);
-        const assertion = requiredAssertion(assertions, expectation.assertion_ref, `semantic_fact_machine_observer_not_admitted:${expectation.proof_ref}`);
-        factBoundAssertions.add(assertion.key);
-        candidates.push({
-            obligation_ref: expectation.proof_ref,
-            observation_identity: expectation.fact_ref,
-            fact_ref: expectation.fact_ref,
-            assertion,
-            target_ref: input.check.execution_target.target_ref,
-            method: expectation.method,
-            expected_value_sha256: expectation.expected.sha256,
-            actual_projection: "raw_exact",
-            comparison: {
-                comparator: expectation.comparison.comparator,
-                mode: expectation.comparison.mode,
-                parameters_sha256: expectation.comparison.parameters.sha256,
-                tolerance_sha256: expectation.comparison.tolerance?.sha256 ?? null,
-                mask_sha256: expectation.comparison.mask?.sha256 ?? null,
-            },
-            sensitivity: expectation.observation_sensitivity,
-            oracle: expectation.oracle,
-            diagnostic_scope: "semantic_fact",
-        });
-    }
-    for (const target of input.design_targets) {
-        if (target.target_ref !== input.check.execution_target.target_ref)
-            fail("machine_observer_not_admitted", `${target.key}:target_mismatch:${target.target_ref}:${input.check.execution_target.target_ref}`);
-        for (const binding of target.verification_method_bindings)
-            for (const artifact of binding.evidence_artifacts)
-                for (const expectation of artifact.fact_expectations) {
-                    const assertion = requiredAssertion(assertions, binding.assertion_ref, `machine_observer_not_admitted:${target.key}:${binding.method}`);
-                    factBoundAssertions.add(assertion.key);
-                    candidates.push({
-                        obligation_ref: designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref),
-                        observation_identity: expectation.fact_ref,
-                        fact_ref: expectation.fact_ref,
-                        assertion,
-                        target_ref: target.target_ref,
-                        method: binding.method,
-                        expected_value_sha256: expectation.expected.sha256,
-                        actual_projection: "raw_exact",
-                        comparison: {
-                            comparator: expectation.comparison.comparator,
-                            mode: expectation.comparison.mode,
-                            parameters_sha256: expectation.comparison.parameters.sha256,
-                            tolerance_sha256: expectation.comparison.tolerance?.sha256 ?? null,
-                            mask_sha256: expectation.comparison.mask?.sha256 ?? null,
-                        },
-                        sensitivity: expectation.observation_sensitivity,
-                        oracle: expectation.oracle,
-                        diagnostic_scope: "design_fact",
-                    });
-                }
-        for (const binding of target.symbolic_method_bindings ?? [])
-            for (const expectation of binding.rule_expectations) {
-                const assertion = requiredAssertion(assertions, binding.assertion_ref, `machine_observer_not_admitted:${target.key}:${binding.method}`);
-                factBoundAssertions.add(assertion.key);
-                if (expectation.proof_surface !== input.check.proof_surface)
-                    fail("unsupported_observer_requires_external_confirmation", `${target.key}:${expectation.obligation_ref}:proof_surface_mismatch`);
-                candidates.push({
-                    obligation_ref: expectation.obligation_ref,
-                    observation_identity: expectation.obligation_ref,
-                    fact_ref: expectation.fact_rule_ref,
-                    assertion,
-                    target_ref: target.target_ref,
-                    method: binding.method,
-                    expected_value_sha256: expectation.expected.sha256,
-                    actual_projection: "raw_exact",
-                    comparison: {
-                        comparator: expectation.comparison.comparator,
-                        mode: expectation.comparison.mode,
-                        parameters_sha256: expectation.comparison.parameters.sha256,
-                        tolerance_sha256: expectation.comparison.tolerance?.sha256 ?? null,
-                        mask_sha256: expectation.comparison.mask?.sha256 ?? null,
-                    },
-                    sensitivity: expectation.observation_sensitivity,
-                    oracle: expectation.oracle,
-                    diagnostic_scope: "design_fact",
-                });
-            }
-    }
-    for (const assertion of assertions.values()) {
-        if (factBoundAssertions.has(assertion.key))
-            continue;
-        const expected = exactAssertionExpected(assertion);
-        const obligationRef = input.external_claim_obligation_refs_by_assertion?.get(assertion.key) ??
-            assertionObligationRef(input.outcome_key, input.check.key, assertion.key);
-        candidates.push({
-            obligation_ref: obligationRef,
-            observation_identity: obligationRef,
-            fact_ref: null,
-            assertion,
-            target_ref: input.check.execution_target.target_ref,
-            method: "exact_value",
-            expected_value_sha256: sha256Hex(canonicalValueJson(expected)),
-            expected_value: expected,
-            actual_projection: assertionActualProjection(assertion),
-            comparison: {
-                comparator: "exact_value",
-                mode: "exact",
-                parameters_sha256: sha256Hex(canonicalValueJson({ comparator: "exact_value" })),
-                tolerance_sha256: null,
-                mask_sha256: null,
-            },
-            sensitivity: "plain",
-            diagnostic_scope: "assertion",
-        });
-    }
-    const rows = candidates.flatMap((candidate) => {
-        try {
-            return [compileCandidate(input, candidate)];
-        }
-        catch (error) {
-            const exactExternalDesign = candidate.diagnostic_scope === "design_fact" &&
-                input.external_design_obligation_refs?.has(candidate.obligation_ref);
-            const exactExternalClaim = candidate.diagnostic_scope === "assertion" &&
-                input.external_claim_obligation_refs_by_assertion?.get(candidate.assertion.key) === candidate.obligation_ref;
-            if ((exactExternalDesign || exactExternalClaim) &&
-                externalizableObservationError(error))
-                return [compileExternalCandidate(input, candidate)];
-            throw error;
-        }
-    });
-    assertUniqueRows(rows);
-    return rows.sort((left, right) => canonicalValueJson(left).localeCompare(canonicalValueJson(right)));
-}
-export function projectExternallyOwnedDesignAssertions(check, designTargets, machineAuthorities, externalDesignObligationRefs) {
-    const obligationsByAssertion = new Map();
-    const add = (assertionRef, obligationRef) => {
-        const refs = obligationsByAssertion.get(assertionRef) ?? [];
-        refs.push(obligationRef);
-        obligationsByAssertion.set(assertionRef, refs);
-    };
-    for (const target of designTargets) {
-        for (const binding of target.verification_method_bindings)
-            for (const artifact of binding.evidence_artifacts)
-                for (const expectation of artifact.fact_expectations)
-                    add(binding.assertion_ref, designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref));
-        for (const binding of target.symbolic_method_bindings ?? [])
-            for (const expectation of binding.rule_expectations)
-                add(binding.assertion_ref, expectation.obligation_ref);
-    }
-    const machineRefs = new Set(machineAuthorities
-        .filter((authority) => authority.authority !== "external_confirmation")
-        .map((authority) => authority.obligation_ref));
-    const removed = new Set();
-    for (const [assertionRef, refs] of obligationsByAssertion) {
-        const externalRefs = refs.filter((ref) => externalDesignObligationRefs.has(ref));
-        if (!externalRefs.length)
-            continue;
-        const admittedMachineRefs = refs.filter((ref) => machineRefs.has(ref));
-        if (admittedMachineRefs.length === refs.length)
-            continue;
-        if (!admittedMachineRefs.length && externalRefs.length === refs.length) {
-            removed.add(assertionRef);
-            continue;
-        }
-        fail("mixed_machine_external_design_assertion", `${check.key}:${assertionRef}:${refs.join(",")}`);
-    }
-    if (!removed.size)
-        return { check, removed_assertion_refs: removed };
-    return {
-        check: {
-            ...check,
-            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
-            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
-        },
-        removed_assertion_refs: removed,
-    };
-}
-export function projectExternallyOwnedClaimAssertions(check, observationAuthorities, externalClaimObligationRefsByAssertion) {
-    const removed = new Set();
-    for (const [assertionRef, obligationRef,] of externalClaimObligationRefsByAssertion) {
-        const authorities = observationAuthorities.filter((authority) => authority.assertion_ref === assertionRef &&
-            authority.obligation_ref === obligationRef);
-        if (authorities.some((authority) => authority.authority !== "external_confirmation"))
-            continue;
-        if (authorities.some((authority) => authority.authority === "external_confirmation"))
-            removed.add(assertionRef);
-    }
-    if (!removed.size)
-        return { check, removed_assertion_refs: removed };
-    return {
-        check: {
-            ...check,
-            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
-            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
-        },
-        removed_assertion_refs: removed,
-    };
-}
-function compileCandidate(input, candidate) {
-    const unimplementedDerivedCapability = candidate.assertion.evidence_capabilities.find((capability) => PROCESS_CAPABILITIES_REQUIRING_A_SEPARATE_PACKAGE_DERIVATION.has(capability));
-    if (unimplementedDerivedCapability)
-        fail("unsupported_observer_requires_external_confirmation", `${candidate.obligation_ref}:${unimplementedDerivedCapability}:package_derivation_required`);
-    if (candidate.oracle && !isJsonPointerExactOracle(candidate.oracle))
-        fail("custom_oracle_machine_completion_forbidden", `${candidate.diagnostic_scope}:${candidate.obligation_ref}:${candidate.oracle.identity ?? "unknown"}`);
-    if (!JSON_POINTER_EXACT_METHODS.includes(candidate.method) ||
-        candidate.comparison.comparator !== "exact_value" ||
-        candidate.comparison.mode !== "exact" ||
-        candidate.comparison.tolerance_sha256 !== null ||
-        candidate.comparison.mask_sha256 !== null ||
-        candidate.sensitivity !== "plain")
-        fail(candidate.diagnostic_scope === "semantic_fact"
-            ? "semantic_fact_machine_observer_not_admitted"
-            : "unsupported_observer_requires_external_confirmation", `${candidate.diagnostic_scope}:${candidate.obligation_ref}:plain_exact_json_required`);
-    const authority = selectAuthority(input, candidate);
-    const carrierRefs = productionCarrierRefs(input);
-    if (authority === "package_static_json_exact") {
-        if (!carrierRefs.length)
-            fail("machine_observer_not_admitted", `${candidate.obligation_ref}:production_binding_carrier_required`);
-        if (carrierRefs.length !== 1)
-            fail("machine_observer_not_admitted", `${candidate.obligation_ref}:static_production_binding_ambiguous`);
-        const staticPaths = carrierRefs[0].carrier_paths;
-        if (staticPaths.length !== 1 || !isExactRepositoryFile(staticPaths[0]))
-            fail("machine_observer_not_admitted", `${candidate.obligation_ref}:static_production_carrier_exact_path_required`);
-    }
-    if (authority === "package_static_json_exact")
-        for (const carrierPath of carrierRefs.flatMap((carrier) => carrier.carrier_paths)) {
-            const carrierRoleIssue = staticObservationCarrierRoleConflict(input, carrierPath);
-            if (carrierRoleIssue)
-                fail("machine_observer_not_admitted", `${candidate.obligation_ref}:${carrierRoleIssue}`);
-        }
-    const comparison = candidate.comparison;
-    const expectedIdentity = sha256Hex(canonicalValueJson({
-        obligation_ref: candidate.obligation_ref,
-        fact_ref: candidate.fact_ref,
-        method: candidate.method,
-        expected_value_sha256: candidate.expected_value_sha256,
-        comparison,
-        actual_projection: candidate.actual_projection,
-        carrier_refs: carrierRefs,
-    }));
-    return {
-        obligation_ref: candidate.obligation_ref,
-        fact_ref: candidate.fact_ref,
-        assertion_ref: candidate.assertion.key,
-        claim_refs: [...candidate.assertion.claims].sort(),
-        target_ref: candidate.target_ref,
-        proof_surface: input.check.proof_surface,
-        method: candidate.method,
-        evidence_capabilities: [
-            ...candidate.assertion.evidence_capabilities,
-        ].sort(),
-        authority,
-        expected_identity: expectedIdentity,
-        expected_value_sha256: candidate.expected_value_sha256,
-        actual_projection: candidate.actual_projection,
-        observation_identity: candidate.observation_identity,
-        comparison,
-        locator_policy: {
-            kind: "fixed_json_pointer",
-            value: observationPointer(candidate.observation_identity),
-        },
-        carrier_refs: carrierRefs,
-        runtime_requirements: runtimeRequirements(input),
-    };
-}
-function compileExternalCandidate(input, candidate) {
-    const carrierRefs = [];
-    const comparison = candidate.comparison;
-    const expectedIdentity = sha256Hex(canonicalValueJson({
-        obligation_ref: candidate.obligation_ref,
-        fact_ref: candidate.fact_ref,
-        method: candidate.method,
-        expected_value_sha256: candidate.expected_value_sha256,
-        comparison,
-        actual_projection: candidate.actual_projection,
-        carrier_refs: carrierRefs,
-    }));
-    return {
-        obligation_ref: candidate.obligation_ref,
-        fact_ref: candidate.fact_ref,
-        assertion_ref: candidate.assertion.key,
-        claim_refs: [...candidate.assertion.claims].sort(),
-        target_ref: candidate.target_ref,
-        proof_surface: input.check.proof_surface,
-        method: candidate.method,
-        evidence_capabilities: [
-            ...candidate.assertion.evidence_capabilities,
-        ].sort(),
-        authority: "external_confirmation",
-        expected_identity: expectedIdentity,
-        expected_value_sha256: candidate.expected_value_sha256,
-        ...(Object.hasOwn(candidate, "expected_value")
-            ? { expected_value: candidate.expected_value }
-            : {}),
-        actual_projection: candidate.actual_projection,
-        observation_identity: candidate.observation_identity,
-        comparison,
-        locator_policy: {
-            kind: "fixed_json_pointer",
-            value: observationPointer(candidate.observation_identity),
-        },
-        carrier_refs: carrierRefs,
-        runtime_requirements: runtimeRequirements(input),
-    };
-}
-function selectAuthority(input, candidate) {
-    const target = input.execution_target;
-    if (target.role !== "product")
-        fail("unsupported_observer_requires_external_confirmation", `${candidate.obligation_ref}:product_target_required`);
-    if (input.check.proof_surface === "implementation_structure") {
-        if (!input.check.input_paths.length)
-            fail("machine_observer_not_admitted", `${candidate.obligation_ref}:static_carrier_required`);
-        if (!capabilitiesAdmitted(candidate.assertion.evidence_capabilities, admittedCapabilities(candidate, STATIC_DERIVED_CAPABILITIES)))
-            fail("unsupported_observer_requires_external_confirmation", `${candidate.obligation_ref}:static_capability_not_admitted`);
-        return "package_static_json_exact";
-    }
-    if (target.runtime_family !== "process" ||
-        input.check.proof_surface === "ui_browser" ||
-        input.check.proof_surface === "population_coverage")
-        fail("unsupported_observer_requires_external_confirmation", `${candidate.obligation_ref}:${target.runtime_family}:${input.check.proof_surface}`);
-    if (input.check.runner.type !== "project_binary" ||
-        input.check.execution_target.entrypoint !== "root" ||
-        input.runner.resolved_target !== target.root_entrypoint)
-        fail("process_observer_direct_root_required", `${candidate.obligation_ref}:${input.runner.resolved_target}:${target.root_entrypoint}`);
-    if (!target.root_argv)
-        fail("process_observer_root_invocation_required", candidate.obligation_ref);
-    if (!sameStringArray(input.check.runner.argv, target.root_argv))
-        fail("process_observer_root_argv_mismatch", `${candidate.obligation_ref}:${canonicalValueJson(input.check.runner.argv)}:${canonicalValueJson(target.root_argv)}`);
-    if (!capabilitiesAdmitted(candidate.assertion.evidence_capabilities, admittedCapabilities(candidate, PROCESS_DERIVED_CAPABILITIES)))
-        fail("unsupported_observer_requires_external_confirmation", `${candidate.obligation_ref}:process_capability_not_admitted`);
-    return "package_process_json_exact";
-}
-function runtimeRequirements(input) {
-    return {
-        runtime_family: input.execution_target.runtime_family,
-        target_role: input.execution_target.role,
-        entrypoint: input.check.execution_target.entrypoint,
-        runner_type: input.check.runner.type,
-        resolved_runner_target: input.runner.resolved_target,
-        declared_root_entrypoint: input.execution_target.root_entrypoint,
-        resolved_runner_argv: [...input.runner.argv],
-        declared_root_argv: input.execution_target.root_argv
-            ? [...input.execution_target.root_argv]
-            : null,
-        effect: input.check.runner.effect,
-        direct_root_match: input.check.runner.type === "project_binary" &&
-            input.check.execution_target.entrypoint === "root" &&
-            input.runner.resolved_target === input.execution_target.root_entrypoint &&
-            input.execution_target.root_argv !== undefined &&
-            sameStringArray(input.check.runner.argv, input.execution_target.root_argv),
-    };
-}
-function assertionActualProjection(assertion) {
-    if (assertion.operator === "equals")
-        return "raw_exact";
-    if (assertion.operator === "exists")
-        return "presence_boolean";
-    if (assertion.operator === "truthy")
-        return "truthy_boolean";
-    if (assertion.operator === "falsy")
-        return "falsy_boolean";
-    fail("machine_observer_not_admitted", `${assertion.key}:exact_equals_or_host_boolean_required`);
-}
-function staticObservationCarrierRoleConflict(input, carrierPath) {
-    const expectedAuthorityPatterns = [
-        ...Object.keys(input.runner.frozen_files),
-        ...(input.protected_authority_paths ?? []),
-    ];
-    const evidencePatterns = [
-        ...input.check.expected_output_paths,
-        ...input.check.artifact_globs,
-    ];
-    const conflict = classifyMachineObservationCarrierRoleConflict({
-        carrier_pattern: carrierPath,
-        expected_authority_patterns: expectedAuthorityPatterns,
-        evidence_role_patterns: evidencePatterns,
-    });
-    if (!conflict)
-        return null;
-    return `static_carrier_${conflict}_forbidden`;
-}
-function sameStringArray(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
-function capabilitiesAdmitted(capabilities, admitted) {
-    return capabilities.every((capability) => admitted.has(capability));
-}
-function admittedCapabilities(candidate, derived) {
-    const admitted = new Set(derived);
-    if (candidate.diagnostic_scope === "semantic_fact")
-        admitted.add("semantic_fact");
-    else if (candidate.diagnostic_scope === "design_fact")
-        admitted.add("design_method");
-    return admitted;
-}
-function productionCarrierRefs(input) {
-    return input.production_bindings
-        .map((scoped) => ({
-        binding_ref: scoped.binding_ref,
-        carrier_paths: scoped.binding.carrier_paths
-            .filter((carrier) => input.check.input_paths.some((inputPath) => classifyRepositoryPatternOverlap(carrier, inputPath).status ===
-            "proven_overlap"))
-            .sort(),
-    }))
-        .filter((binding) => binding.carrier_paths.length)
-        .sort((left, right) => left.binding_ref.localeCompare(right.binding_ref));
-}
-function isExactRepositoryFile(value) {
-    try {
-        normalizeRepositoryFile(value, "static_observation_carrier");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function exactAssertionExpected(assertion) {
-    if (assertion.operator === "equals")
-        return assertion.expected;
-    if (assertion.operator === "truthy" || assertion.operator === "exists")
-        return true;
-    if (assertion.operator === "falsy")
-        return false;
-    fail("machine_observer_not_admitted", `${assertion.key}:exact_equals_or_host_boolean_required`);
-}
-function requiredAssertion(assertions, assertionRef, diagnostic) {
-    const assertion = assertions.get(assertionRef);
-    if (!assertion)
-        throw new Error(diagnostic);
-    return assertion;
-}
-function externalizableObservationError(error) {
-    if (!(error instanceof Error))
-        return false;
-    return [
-        "unsupported_observer_requires_external_confirmation:",
-        "custom_oracle_machine_completion_forbidden:",
-        "machine_observer_not_admitted:",
-        "process_observer_direct_root_required:",
-        "process_observer_root_invocation_required:",
-        "process_observer_root_argv_mismatch:",
-    ].some((prefix) => error.message.startsWith(prefix));
-}
-export function assertionObligationRef(outcomeKey, checkKey, assertionKey) {
-    return `assertion.${outcomeKey ?? "GLOBAL"}.${checkKey}.${assertionKey}`;
-}
-function observationPointer(identity) {
-    return `/observations/${identity.replace(/~/gu, "~0").replace(/\//gu, "~1")}`;
-}
-function assertUniqueRows(rows) {
-    const identities = new Set();
-    for (const row of rows) {
-        const identity = `${row.assertion_ref}\0${row.obligation_ref}\0${row.method}`;
-        if (identities.has(identity))
-            fail("machine_observer_not_admitted", `duplicate:${identity}`);
-        identities.add(identity);
-    }
-}
-function fail(code, detail) {
-    throw new Error(`${code}:${detail}`);
-}

package/dist/lib/long-task-observation-ownership.d.ts

@@ -1,2 +0,0 @@
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
-export declare function validateRawExecutionObservationOwnership(checks: CompiledCheckV2[]): void;

package/dist/lib/long-task-observation-ownership.js

@@ -1,22 +0,0 @@
-export function validateRawExecutionObservationOwnership(checks) {
-    const byExecution = new Map();
-    for (const check of checks) {
-        let observations = byExecution.get(check.raw_execution_identity);
-        if (!observations) {
-            observations = new Map();
-            byExecution.set(check.raw_execution_identity, observations);
-        }
-        for (const assertion of [
-            ...check.positive_assertions,
-            ...check.negative_assertions,
-        ]) {
-            if (!assertion.claims.length)
-                continue;
-            const owner = `${check.outcome_key ?? "GLOBAL"}.${check.key}.${assertion.key}`;
-            const previous = observations.get(assertion.observation);
-            if (previous)
-                throw new Error(`raw_execution_observation_reused:${check.raw_execution_identity}:${assertion.observation}:${previous}:${owner}`);
-            observations.set(assertion.observation, owner);
-        }
-    }
-}

package/dist/lib/long-task-outcome-parser.d.ts

@@ -1,4 +0,0 @@
-import type { DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
-export declare function parseOutcome(value: unknown, label: string): DeliveryOutcomeV2;
-export declare function parseOutcomeFragment(raw: string, relative: string): DeliveryOutcomeV2[];
-export declare function safeFragmentPath(value: string, index: number): string;

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

@@ -1,143 +0,0 @@
-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, 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";
-import { parseSemanticFactOutcomeBindings } from "./long-task-semantic-fact-shape.js";
-export function parseOutcome(value, label) {
-    assertNoSemanticDriftMigration(semanticDriftOutcomeMigrationFields(value, label));
-    const row = object(value, label, [
-        "key",
-        "title",
-        "stage",
-        "applicability",
-        "semantic_fact_bindings",
-        "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",
-    ]);
-    const technical = object(row.technical, `${label}.technical`, ["expected_change_paths"], [
-        "obligations",
-        "allowed_support_paths",
-        "forbidden_paths",
-        "forbidden_shortcuts",
-        "bindings",
-        "rollback_and_recovery",
-    ]);
-    const acceptance = object(row.acceptance, `${label}.acceptance`, ["checks"], ["population", "counterfactual_controls"]);
-    return {
-        key: key(row.key, `${label}.key`),
-        title: string(row.title, `${label}.title`),
-        stage: key(row.stage, `${label}.stage`),
-        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`),
-        semantic_fact_bindings: parseSemanticFactOutcomeBindings(row.semantic_fact_bindings, `${label}.semantic_fact_bindings`),
-        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`),
-            requirements: Object.hasOwn(product, "requirements")
-                ? parseRequirements(product.requirements, `${label}.product.requirements`)
-                : [],
-            owner_surfaces: Object.hasOwn(product, "owner_surfaces")
-                ? strings(product.owner_surfaces, `${label}.product.owner_surfaces`)
-                : [],
-            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")
-                ? parseApplicableKeyedStatements(product.non_completing_outcomes, `${label}.product.non_completing_outcomes`)
-                : [],
-        },
-        technical: {
-            obligations: Object.hasOwn(technical, "obligations")
-                ? parseObligations(technical.obligations, `${label}.technical.obligations`)
-                : [],
-            expected_change_paths: repositoryPatterns(technical.expected_change_paths, `${label}.technical.expected_change_paths`),
-            allowed_support_paths: Object.hasOwn(technical, "allowed_support_paths")
-                ? repositoryPatterns(technical.allowed_support_paths, `${label}.technical.allowed_support_paths`)
-                : [],
-            forbidden_paths: Object.hasOwn(technical, "forbidden_paths")
-                ? repositoryPatterns(technical.forbidden_paths, `${label}.technical.forbidden_paths`)
-                : [],
-            forbidden_shortcuts: Object.hasOwn(technical, "forbidden_shortcuts")
-                ? parseApplicableKeyedStatements(technical.forbidden_shortcuts, `${label}.technical.forbidden_shortcuts`)
-                : [],
-            bindings: Object.hasOwn(technical, "bindings")
-                ? parseBindings(technical.bindings, `${label}.technical.bindings`)
-                : [],
-            rollback_and_recovery: Object.hasOwn(technical, "rollback_and_recovery")
-                ? nullable(technical.rollback_and_recovery, (item) => parseRollback(item, `${label}.technical.rollback_and_recovery`))
-                : null,
-        },
-        acceptance: {
-            checks: array(acceptance.checks, `${label}.acceptance.checks`).map((item, index) => parseCheck(item, `${label}.acceptance.checks[${index}]`)),
-            population: Object.hasOwn(acceptance, "population")
-                ? nullable(acceptance.population, (item) => parsePopulation(item, `${label}.acceptance.population`))
-                : null,
-            counterfactual_controls: Object.hasOwn(acceptance, "counterfactual_controls")
-                ? parseCounterfactuals(acceptance.counterfactual_controls, `${label}.acceptance.counterfactual_controls`)
-                : [],
-        },
-    };
-}
-export function parseOutcomeFragment(raw, relative) {
-    const value = parseStrictYaml(raw);
-    if (Array.isArray(value))
-        return value.map((item, index) => parseOutcome(item, `${relative}[${index}]`));
-    const row = object(value, relative, [], [
-        "schema_version",
-        "outcomes",
-        "key",
-        "title",
-        "stage",
-        "depends_on",
-        "applicability",
-        "semantic_fact_bindings",
-        "product",
-        "technical",
-        "acceptance",
-    ]);
-    if (Object.hasOwn(row, "outcomes")) {
-        if (Object.keys(row).some((name) => !["schema_version", "outcomes"].includes(name)))
-            throw new Error(`delivery_contract_invalid:${relative}:fragment cannot mix root or Outcome keys`);
-        if (Object.hasOwn(row, "schema_version"))
-            literal(row.schema_version, ["long-task-outcomes-v2"], `${relative}.schema_version`);
-        return array(row.outcomes, `${relative}.outcomes`).map((item, index) => parseOutcome(item, `${relative}.outcomes[${index}]`));
-    }
-    return [parseOutcome(value, relative)];
-}
-export function safeFragmentPath(value, index) {
-    const normalized = normalizeRepositoryFile(value, `outcome_files[${index}]`);
-    if (!normalized.endsWith(".yaml"))
-        throw new Error(`unsafe_path:outcome_files[${index}]:${value}`);
-    return normalized;
-}