project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,243 +0,0 @@
-import { captureContextGraphSnapshot } from "./context-graph-snapshot.js";
-import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.js";
-import { compileProductClaimCoverage, } from "./long-task-claims.js";
-import { hashDeclaredFiles, validateCounterfactualPaths, validateTechnicalPaths, validateVerificationInputSeparation, } from "./long-task-delivery-preflight.js";
-import { validateClaimEvidenceSensitivity } from "./long-task-evidence-sensitivity-policy.js";
-import { validateSemanticConformance } from "./long-task-conformance-policy.js";
-import { deliveryContractStructureDiagnostics, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
-import { validateRawExecutionObservationOwnership } from "./long-task-observation-ownership.js";
-import { validateLongTaskDesignResourceHandoffs } from "./long-task-design-resource-handoff.js";
-import { validateLongTaskSemanticFactClosure } from "./long-task-semantic-fact-closure.js";
-import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
-import { scopeDeliveryBindings } from "./long-task-scoped-binding.js";
-import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
-import { validateSourceContinuity } from "./long-task-source-continuity.js";
-import { compileSourceInventory } from "./long-task-source-inventory.js";
-import { validateSourceTargetContinuity } from "./long-task-source-target-continuity.js";
-import { validateSourceAnchors } from "./long-task-source-validation.js";
-import { captureWorkspaceManifest, repoRelative, } from "./long-task-workspace.js";
-export async function validateContractForActivation(options) {
-    const { contract, repository, workdir, mode } = options;
-    const diagnostics = options.diagnostics ?? [];
-    const structureOptions = {
-        allowDeferredDesignComponentBindingClosure: true,
-    };
-    if (mode === "collect")
-        for (const error of deliveryContractStructureDiagnostics(contract, structureOptions))
-            addDiagnosticError(diagnostics, error);
-    else
-        validateDeliveryContractStructure(contract, structureOptions);
-    const claims = await attempt(mode, diagnostics, () => compileProductClaimCoverage(contract));
-    if (mode === "fail_fast") {
-        const decisions = contract.source_claims
-            .filter((claim) => claim.disposition.type === "decision_required")
-            .map((claim) => claim.key);
-        if (decisions.length)
-            throw new Error(`source_claim_decision_required:${decisions.join(",")}`);
-    }
-    const sourceHashes = await attempt(mode, diagnostics, () => hashDeclaredFiles(repository, contract.task.source_paths, "source"));
-    await attempt(mode, diagnostics, () => validateSourceAnchors(repository, contract.source_claims));
-    let sourceBackedExecutionTargets = new Map();
-    const sourceItems = await attempt(mode, diagnostics, async () => {
-        const items = await compileSourceInventory(repository, contract.task.source_paths);
-        validateSourceContinuity(contract, items, mode === "collect"
-            ? (error) => addDiagnosticError(diagnostics, new Error(error))
-            : undefined);
-        sourceBackedExecutionTargets = validateSourceTargetContinuity(contract, items, mode === "collect"
-            ? (error) => addDiagnosticError(diagnostics, new Error(error))
-            : undefined);
-        return items;
-    });
-    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems ?? []));
-    const risk = await attempt(mode, diagnostics, () => {
-        const decision = classifyLongTaskRisk(contract);
-        validateRiskProof(contract, decision);
-        return decision;
-    });
-    const context = await attempt(mode, diagnostics, () => captureContextGraphSnapshot(repository, contract.task.context_refs, contract.task.context_snapshot_mode));
-    const semanticFactClosure = sourceItems && context
-        ? await attempt(mode, diagnostics, () => validateLongTaskSemanticFactClosure(contract, repository, sourceItems, context.files))
-        : null;
-    const workdirRelative = repoRelative(repository, workdir);
-    const workspace = await attempt(mode, diagnostics, async () => {
-        const manifest = await captureWorkspaceManifest(repository, workdir);
-        validateTechnicalPaths(contract, repository, workdirRelative, manifest);
-        return manifest;
-    });
-    if (!workspace)
-        return emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context);
-    const observationAuthorityPaths = [
-        ...workspace.files
-            .map((file) => file.path)
-            .filter((file) => file === workdirRelative || file.startsWith(`${workdirRelative}/`)),
-        `${workdirRelative}/delivery-contract.yaml`,
-        ...Object.keys(sourceHashes ?? {}),
-        ...(context?.files ?? []),
-    ];
-    const globalChecks = [];
-    for (const check of contract.global.acceptance.checks) {
-        const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
-        if (!executionTarget)
-            continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], contract.outcomes.flatMap((outcome) => scopeDeliveryBindings(outcome.key, outcome.technical.bindings)), contract.outcomes.flatMap((outcome) => outcome.product.owner.path_globs), sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), null, check.key);
-        if (frozen)
-            globalChecks.push(frozen);
-    }
-    const outcomes = [];
-    for (const outcome of contract.outcomes) {
-        const checks = [];
-        const blockedDesignAssertionRefsByCheck = new Map();
-        for (const check of outcome.acceptance.checks) {
-            const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
-            if (!executionTarget)
-                continue;
-            const blockedDesignAssertionRefs = externallyBlockedDesignAssertionRefs(outcome, check, contract.global.acceptance.external_confirmations);
-            blockedDesignAssertionRefsByCheck.set(check.key, blockedDesignAssertionRefs);
-            const machineCheck = projectMachineCheck(check, blockedDesignAssertionRefs);
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(machineCheck, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key, contract.global.acceptance.external_confirmations), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
-            if (frozen)
-                checks.push(frozen);
-        }
-        outcomes.push({
-            ...outcome,
-            internal_id: `OUT.${outcome.key}`,
-            generated_claims: claims?.by_outcome[outcome.key] ?? [],
-            risk_reasons: risk?.reasons_by_outcome[outcome.key] ?? [],
-            acceptance: {
-                ...outcome.acceptance,
-                checks,
-                counterfactual_controls: outcome.acceptance.counterfactual_controls.map((control) => projectCounterfactualControl(control, outcome.acceptance.checks.find((check) => check.key === control.check_key), blockedDesignAssertionRefsByCheck.get(control.check_key) ??
-                    new Set())),
-            },
-        });
-    }
-    const allChecks = [
-        ...globalChecks,
-        ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-    await attempt(mode, diagnostics, () => validateVerificationInputSeparation(contract, allChecks, workdirRelative));
-    await attempt(mode, diagnostics, () => validateRawExecutionObservationOwnership(allChecks));
-    if (allGlobalChecksFrozen(contract, globalChecks) &&
-        allOutcomeChecksFrozen(contract, outcomes)) {
-        await attempt(mode, diagnostics, () => validateCounterfactualPaths(contract, globalChecks, outcomes, repository, workdirRelative, [
-            ...contract.task.source_paths,
-            ...(context?.files ?? contract.task.context_refs),
-        ]));
-        await attempt(mode, diagnostics, () => validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, mode === "collect"
-            ? (error) => addDiagnosticError(diagnostics, new Error(error))
-            : undefined));
-        if (risk)
-            await attempt(mode, diagnostics, () => validateSemanticConformance(contract, risk.effective_level, allChecks, mode === "collect"
-                ? (error) => addDiagnosticError(diagnostics, new Error(error))
-                : undefined));
-    }
-    return {
-        claims,
-        risk,
-        source_hashes: sourceHashes,
-        source_items: sourceItems,
-        context_snapshot: context,
-        workspace,
-        global_checks: globalChecks,
-        outcomes,
-    };
-}
-function designTargetsForCheck(outcome, checkKey, confirmations) {
-    return (outcome.product.surface_bindings ?? []).flatMap((binding) => binding.design_targets
-        .filter((target) => target.conformance_check_ref === checkKey &&
-        !confirmations.some((confirmation) => confirmation.blocks_target &&
-            confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`))))
-        .map((target) => ({
-        ...target,
-        surface_binding_ref: binding.key,
-        surface_ref: binding.surface_ref,
-        target_ref: binding.target_ref,
-    })));
-}
-function externallyBlockedDesignAssertionRefs(outcome, check, confirmations) {
-    const refs = new Set();
-    const impactedClaims = new Set();
-    for (const binding of outcome.product.surface_bindings ?? [])
-        for (const target of binding.design_targets) {
-            if (target.conformance_check_ref !== check.key)
-                continue;
-            const blocked = confirmations.some((confirmation) => confirmation.blocks_target &&
-                confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)));
-            if (!blocked)
-                continue;
-            for (const confirmation of confirmations)
-                if (confirmation.blocks_target &&
-                    confirmation.impact_claims.some((claimRef) => target.claim_refs.some((targetClaimRef) => claimRef === `${outcome.key}.${targetClaimRef}`)))
-                    for (const claimRef of confirmation.impact_claims)
-                        impactedClaims.add(claimRef);
-            refs.add(target.conformance_assertion_ref);
-            for (const method of target.verification_method_bindings)
-                refs.add(method.assertion_ref);
-            for (const method of target.symbolic_method_bindings ?? [])
-                refs.add(method.assertion_ref);
-            if (target.symbolic_certificate_binding)
-                refs.add(target.symbolic_certificate_binding.assertion_ref);
-        }
-    for (const assertion of [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ])
-        if (assertion.evidence_capabilities.includes("state_delta") &&
-            assertion.claims.length > 0 &&
-            assertion.claims.every((claimRef) => impactedClaims.has(`${outcome.key}.${claimRef}`)))
-            refs.add(assertion.key);
-    return refs;
-}
-function projectMachineCheck(check, externallyBlockedAssertionRefs) {
-    if (!externallyBlockedAssertionRefs.size)
-        return check;
-    return {
-        ...check,
-        positive_assertions: check.positive_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
-        negative_assertions: check.negative_assertions.filter((assertion) => !externallyBlockedAssertionRefs.has(assertion.key)),
-    };
-}
-function projectCounterfactualControl(control, check, externallyBlockedAssertionRefs) {
-    if (!check || !externallyBlockedAssertionRefs.size)
-        return control;
-    const externallyBlockedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
-        .filter((assertion) => externallyBlockedAssertionRefs.has(assertion.key))
-        .flatMap((assertion) => assertion.claims));
-    return {
-        ...control,
-        claims: control.claims.filter((claimRef) => !externallyBlockedClaims.has(claimRef)),
-        expected_assertion_failures: control.expected_assertion_failures.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
-        preserved_assertions: control.preserved_assertions.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
-    };
-}
-async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
-    try {
-        return await action();
-    }
-    catch (error) {
-        if (mode === "fail_fast")
-            throw error;
-        addDiagnosticError(diagnostics, error, outcomeKey, checkKey);
-        return null;
-    }
-}
-function emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context) {
-    return {
-        claims,
-        risk,
-        source_hashes: sourceHashes,
-        source_items: sourceItems,
-        context_snapshot: context,
-        workspace: null,
-        global_checks: [],
-        outcomes: [],
-    };
-}
-function allGlobalChecksFrozen(contract, checks) {
-    return checks.length === contract.global.acceptance.checks.length;
-}
-function allOutcomeChecksFrozen(contract, outcomes) {
-    return outcomes.every((outcome) => outcome.acceptance.checks.length ===
-        contract.outcomes.find((item) => item.key === outcome.key).acceptance
-            .checks.length);
-}

package/dist/lib/long-task-admitted-observation-records.d.ts

@@ -1,25 +0,0 @@
-import type { EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
-import type { JsonPointerExactLocator } from "./long-task-json-pointer-observation.js";
-export type AdmittedObservationCandidate = {
-    assertion_key: string;
-    identity_ref: string;
-    method: string;
-    actual_observation: {
-        artifact_path: string;
-        locator: JsonPointerExactLocator;
-        sensitivity: string;
-    };
-    comparison: {
-        comparator: string;
-        mode: string;
-        tolerance: unknown;
-        mask: unknown;
-    };
-    oracle: {
-        trust: string;
-        identity: string;
-        version: string;
-        sha256: string | null;
-    };
-};
-export declare function admittedObservationCandidates(records: EvidenceCapabilityRecordV2[]): AdmittedObservationCandidate[];

package/dist/lib/long-task-admitted-observation-records.js

@@ -1,40 +0,0 @@
-export function admittedObservationCandidates(records) {
-    const candidates = [];
-    for (const record of records) {
-        if (record.capability === "semantic_fact") {
-            candidates.push({
-                assertion_key: record.assertion_key,
-                identity_ref: record.fact_ref,
-                method: record.method,
-                actual_observation: record.actual_observation,
-                comparison: record.comparison,
-                oracle: record.oracle,
-            });
-            continue;
-        }
-        if (record.capability !== "design_method")
-            continue;
-        if ("fact_model" in record)
-            for (const result of record.rule_results)
-                candidates.push({
-                    assertion_key: record.assertion_key,
-                    identity_ref: result.obligation_ref,
-                    method: record.method,
-                    actual_observation: result.actual_observation,
-                    comparison: result.comparison,
-                    oracle: result.oracle,
-                });
-        else
-            for (const cell of record.cells)
-                for (const result of cell.fact_results)
-                    candidates.push({
-                        assertion_key: record.assertion_key,
-                        identity_ref: result.fact_ref,
-                        method: record.method,
-                        actual_observation: result.actual_observation,
-                        comparison: result.comparison,
-                        oracle: result.oracle,
-                    });
-    }
-    return candidates;
-}

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

@@ -1,93 +0,0 @@
-import type { CompiledCheckV2, CompiledObservationAuthorityV2, EvidenceCapabilityRecordV2, PackageObservationValueV2 } from "./long-task-delivery-types.js";
-import { type ExactDigestComparisonResult } from "./long-task-exact-comparison.js";
-import { JSON_POINTER_EXACT_CAPABILITY, type JsonPointerExactLocator, type JsonPointerExactObservation } from "./long-task-json-pointer-observation.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, createJsonPointerExactBudget, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
-export type { JsonPointerExactBudget, JsonPointerExactLocator, JsonPointerExactObservation, } from "./long-task-json-pointer-observation.js";
-export { extractJsonPointerExactObservation } from "./long-task-observation-artifact.js";
-export interface PreparedAdmittedObservation {
-    assertion_key: string;
-    identity_ref: string;
-    authority_key: string | null;
-    obligation_ref: string | null;
-    method: string;
-    observation_key: string;
-    authority: CompiledObservationAuthorityV2["authority"] | null;
-    raw_value: unknown;
-    observation: JsonPointerExactObservation | null;
-    comparison: ExactDigestComparisonResult | null;
-    reason: string | null;
-}
-export interface PreparedAdmittedObservationSet {
-    readonly by_observation_key: ReadonlyMap<string, PreparedAdmittedObservation>;
-    readonly by_authority_key: ReadonlyMap<string, PreparedAdmittedObservation>;
-    readonly entries: readonly PreparedAdmittedObservation[];
-}
-export declare function prepareAdmittedObservations(input: {
-    check: CompiledCheckV2;
-    records: EvidenceCapabilityRecordV2[];
-    snapshot_root: string;
-    authority_paths?: readonly string[];
-    package_observations?: readonly PackageObservationValueV2[];
-}): Promise<PreparedAdmittedObservationSet>;
-export declare function admittedObservationAuthorityKey(authority: Pick<CompiledObservationAuthorityV2, "assertion_ref" | "obligation_ref" | "method">): string;
-export declare function resolveObservationAuthority(check: CompiledCheckV2, candidate: {
-    assertion_key: string;
-    identity_ref: string;
-    method: string;
-}): {
-    authority: CompiledObservationAuthorityV2;
-    reason: null;
-} | {
-    authority: null;
-    reason: string;
-};
-export declare function admittedObservationKey(artifactPath: string, locator: JsonPointerExactLocator): string;
-export declare function jsonPointerExactLocatorForIdentity(identity: string): {
-    kind: "json_pointer";
-    value: string;
-};
-export type ObservationCarrierRole = "expected_authority_forbidden" | "product_carrier" | "current_observer_artifact" | "unadmitted_evidence";
-export type MachineObservationCarrierRoleConflict = "expected_authority" | "evidence_role";
-export declare function classifyMachineObservationCarrierRoleConflict(input: {
-    carrier_pattern: string;
-    expected_authority_patterns: readonly string[];
-    evidence_role_patterns: readonly string[];
-}): MachineObservationCarrierRoleConflict | null;
-export declare function classifyObservationCarrier(input: {
-    artifact_path: string;
-    source_paths: string[];
-    expected_authority_paths: string[];
-    product_carrier_paths: string[];
-    current_observer_artifact_paths: string[];
-}): ObservationCarrierRole;
-export interface ObservationAdmissionInput {
-    method: string;
-    comparator: string;
-    mode: string;
-    tolerance: unknown;
-    mask: unknown;
-    sensitivity: string;
-    locator: JsonPointerExactLocator;
-    oracle: {
-        trust?: string;
-        identity?: string;
-        version?: string;
-        sha256?: string | null;
-    };
-    target_family: string;
-    observed_target_family?: string;
-    required_method?: string;
-    current_static_artifact: boolean;
-    historical_session?: boolean;
-    snapshot_matches?: boolean;
-}
-export type ObservationAdmissionDecision = {
-    authority: "machine";
-    reason: null;
-    capability: typeof JSON_POINTER_EXACT_CAPABILITY;
-} | {
-    authority: "external_confirmation";
-    reason: string;
-    capability: null;
-};
-export declare function observationAdmissionDecision(input: ObservationAdmissionInput): ObservationAdmissionDecision;

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

@@ -1,201 +0,0 @@
-import { classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { evaluateExactDigestComparison, } from "./long-task-exact-comparison.js";
-import { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_METHODS, isJsonPointerExactOracle, normalizeObservationArtifactPath, validateJsonPointerExactLocator, } from "./long-task-json-pointer-observation.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, createJsonPointerExactBudget, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
-export { extractJsonPointerExactObservation } from "./long-task-observation-artifact.js";
-export async function prepareAdmittedObservations(input) {
-    const entries = [];
-    const entriesByAuthority = new Map();
-    for (const authority of input.check.observation_authorities ?? []) {
-        const authorityKey = admittedObservationAuthorityKey(authority);
-        const candidates = (input.package_observations ?? []).filter((candidate) => candidate.authority === authority.authority &&
-            candidate.observation_identity === authority.observation_identity &&
-            candidate.assertion_ref === authority.assertion_ref &&
-            candidate.obligation_ref === authority.obligation_ref &&
-            candidate.method === authority.method);
-        const candidate = candidates.length === 1 ? candidates[0] : null;
-        let reason = null;
-        let comparison = null;
-        if (authority.authority === "external_confirmation")
-            reason = "unsupported_observer_requires_external_confirmation";
-        else if (candidates.length > 1)
-            reason = "admitted_observation_duplicate";
-        else if (!candidate)
-            reason =
-                authority.authority === "package_process_json_exact"
-                    ? "admitted_observation_runtime_required"
-                    : "admitted_observation_missing";
-        else if (candidate.reason)
-            reason = candidate.reason;
-        else if (!candidate.observation)
-            reason = "admitted_observation_missing";
-        else if (candidate.observation.locator.kind !== "json_pointer" ||
-            candidate.observation.locator.value !== authority.locator_policy.value)
-            reason = "observation_locator_identity_mismatch";
-        else {
-            try {
-                comparison = evaluateExactDigestComparison({
-                    identity: {
-                        kind: "compiled_observation_authority",
-                        expected_identity: authority.expected_identity,
-                        obligation_ref: authority.obligation_ref,
-                        observation_identity: authority.observation_identity,
-                        target_ref: authority.target_ref,
-                        method: authority.method,
-                    },
-                    actual_value_sha256: projectedActualValueSha256(authority, candidate),
-                    expected_value_sha256: authority.expected_value_sha256,
-                    comparator: authority.comparison.comparator,
-                    mode: authority.comparison.mode,
-                    parameters_sha256: authority.comparison.parameters_sha256 ?? "",
-                    tolerance_sha256: authority.comparison.tolerance_sha256,
-                    mask_sha256: authority.comparison.mask_sha256,
-                });
-            }
-            catch (error) {
-                reason = error instanceof Error ? error.message : String(error);
-            }
-        }
-        const entry = {
-            assertion_key: authority.assertion_ref,
-            identity_ref: authority.observation_identity,
-            authority_key: authorityKey,
-            obligation_ref: authority.obligation_ref,
-            method: authority.method,
-            observation_key: candidate?.observation
-                ? admittedObservationKey(candidate.observation.artifact_path, candidate.observation.locator)
-                : `compiled-authority\0${authorityKey}`,
-            authority: authority.authority,
-            raw_value: candidate?.raw_value,
-            observation: candidate?.observation ?? null,
-            comparison,
-            reason,
-        };
-        entries.push(entry);
-        entriesByAuthority.set(authorityKey, entry);
-    }
-    for (const candidate of input.package_observations ?? []) {
-        const matches = (input.check.observation_authorities ?? []).filter((authority) => authority.authority === candidate.authority &&
-            authority.observation_identity === candidate.observation_identity &&
-            authority.assertion_ref === candidate.assertion_ref &&
-            authority.obligation_ref === candidate.obligation_ref &&
-            authority.method === candidate.method);
-        if (matches.length)
-            continue;
-        entries.push({
-            assertion_key: "",
-            identity_ref: candidate.observation_identity,
-            authority_key: null,
-            obligation_ref: null,
-            method: "exact_value",
-            observation_key: candidate.observation
-                ? admittedObservationKey(candidate.observation.artifact_path, candidate.observation.locator)
-                : `unbound-package-observation\0${candidate.observation_identity}`,
-            authority: null,
-            raw_value: candidate.raw_value,
-            observation: candidate.observation,
-            comparison: null,
-            reason: "machine_observer_not_admitted",
-        });
-    }
-    return {
-        by_observation_key: new Map(entries.map((entry) => [entry.observation_key, entry])),
-        by_authority_key: entriesByAuthority,
-        entries,
-    };
-}
-function projectedActualValueSha256(authority, candidate) {
-    if (!candidate.observation)
-        throw new Error("admitted_observation_missing");
-    if (authority.actual_projection === "raw_exact")
-        return candidate.observation.value_sha256;
-    const projected = authority.actual_projection === "presence_boolean"
-        ? true
-        : Boolean(candidate.raw_value);
-    return sha256Hex(canonicalValueJson(projected));
-}
-export function admittedObservationAuthorityKey(authority) {
-    return `${authority.assertion_ref}\0${authority.obligation_ref}\0${authority.method}`;
-}
-export function resolveObservationAuthority(check, candidate) {
-    const matches = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === candidate.assertion_key &&
-        authority.method === candidate.method &&
-        authority.observation_identity === candidate.identity_ref);
-    if (matches.length === 1)
-        return { authority: matches[0], reason: null };
-    return {
-        authority: null,
-        reason: matches.length === 0
-            ? "machine_observer_not_admitted"
-            : "machine_observer_authority_ambiguous",
-    };
-}
-export function admittedObservationKey(artifactPath, locator) {
-    return `${artifactPath}\0${canonicalValueJson(locator)}`;
-}
-export function jsonPointerExactLocatorForIdentity(identity) {
-    return {
-        kind: "json_pointer",
-        value: `/observations/${identity.replace(/~/gu, "~0").replace(/\//gu, "~1")}`,
-    };
-}
-export function classifyMachineObservationCarrierRoleConflict(input) {
-    if (input.expected_authority_patterns.some((pattern) => classifyRepositoryPatternOverlap(input.carrier_pattern, pattern)
-        .status === "proven_overlap"))
-        return "expected_authority";
-    if (input.evidence_role_patterns.some((pattern) => classifyRepositoryPatternOverlap(input.carrier_pattern, pattern)
-        .status === "proven_overlap"))
-        return "evidence_role";
-    return null;
-}
-export function classifyObservationCarrier(input) {
-    const artifactPath = normalizeObservationArtifactPath(input.artifact_path);
-    if (matchesAny(artifactPath, input.source_paths) ||
-        matchesAny(artifactPath, input.expected_authority_paths))
-        return "expected_authority_forbidden";
-    if (matchesAny(artifactPath, input.product_carrier_paths))
-        return "product_carrier";
-    if (matchesAny(artifactPath, input.current_observer_artifact_paths))
-        return "current_observer_artifact";
-    return "unadmitted_evidence";
-}
-export function observationAdmissionDecision(input) {
-    if (input.observed_target_family !== undefined &&
-        input.observed_target_family !== input.target_family)
-        return external("observation_target_proxy_mismatch");
-    if (input.required_method && input.required_method !== input.method)
-        return external("observation_capability_mismatch");
-    if (input.target_family !== "process" ||
-        input.historical_session === true ||
-        !input.current_static_artifact ||
-        input.snapshot_matches === false)
-        return external("observation_current_static_target_required");
-    if (!isJsonPointerExactOracle(input.oracle))
-        return external("observation_oracle_not_admitted");
-    if (!JSON_POINTER_EXACT_METHODS.some((method) => method === input.method) ||
-        input.comparator !== "exact_value" ||
-        input.mode !== "exact" ||
-        input.tolerance !== null ||
-        input.mask !== null)
-        return external("observation_method_not_admitted");
-    if (input.sensitivity !== "plain")
-        return external("observation_protected_requires_frozen_adapter");
-    try {
-        validateJsonPointerExactLocator(input.locator);
-    }
-    catch {
-        return external("observation_locator_not_admitted");
-    }
-    return {
-        authority: "machine",
-        reason: null,
-        capability: JSON_POINTER_EXACT_CAPABILITY,
-    };
-}
-function external(reason) {
-    return { authority: "external_confirmation", reason, capability: null };
-}
-function matchesAny(candidate, patterns) {
-    return patterns.some((pattern) => matchesRepoPattern(candidate, pattern));
-}

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

@@ -1,4 +0,0 @@
-import type { ApplicableKeyedStatementV2, ClaimApplicabilityV2 } from "./long-task-semantic-contract-types.js";
-export declare function parseClaimApplicability(value: unknown, label: string): ClaimApplicabilityV2[];
-export declare function parseApplicableKeyedStatements(value: unknown, label: string): ApplicableKeyedStatementV2[];
-export declare function parseKeyRefs(value: unknown, label: string): string[];

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

@@ -1,54 +0,0 @@
-import { array, key, literal, object, semanticRef, string, strings, } from "./long-task-shape-primitives.js";
-const JOURNEY_ROLES = [
-    "success",
-    "degradation",
-    "recovery",
-    "stage_gate",
-    "conformance",
-];
-export function parseClaimApplicability(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "target_ref",
-            "journey_role",
-            "dimensions",
-            "given_refs",
-            "when_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            target_ref: key(row.target_ref, `${itemLabel}.target_ref`),
-            journey_role: literal(row.journey_role, JOURNEY_ROLES, `${itemLabel}.journey_role`),
-            dimensions: array(row.dimensions, `${itemLabel}.dimensions`).map((dimension, dimensionIndex) => {
-                const dimensionLabel = `${itemLabel}.dimensions[${dimensionIndex}]`;
-                const entry = object(dimension, dimensionLabel, ["key", "value"]);
-                return {
-                    key: semanticRef(entry.key, `${dimensionLabel}.key`),
-                    value: semanticRef(entry.value, `${dimensionLabel}.value`),
-                };
-            }),
-            given_refs: parseKeyRefs(row.given_refs, `${itemLabel}.given_refs`),
-            when_refs: parseKeyRefs(row.when_refs, `${itemLabel}.when_refs`),
-        };
-    });
-}
-export function parseApplicableKeyedStatements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "applicability_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}
-export function parseKeyRefs(value, label) {
-    return strings(value, label).map((item, index) => key(item, `${label}[${index}]`));
-}