project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,2 +0,0 @@
-import type { SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function parseSourceClaims(value: unknown, label: string): SourceClaimV2[];

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

@@ -1,64 +0,0 @@
-import { array, fail, key, literal, object, repositorySourceRef, string, strings, } from "./long-task-shape-primitives.js";
-export function parseSourceClaims(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "source_ref", "statement", "disposition"], ["judgment_basis"]);
-        const disposition = object(row.disposition, `${itemLabel}.disposition`, ["type"], ["refs", "ref", "reason"]);
-        const type = literal(disposition.type, [
-            "claim",
-            "acceptance",
-            "outcome_result",
-            "global_constraint",
-            "risk_fact",
-            "external_confirmation",
-            "out_of_scope",
-            "decision_required",
-        ], `${itemLabel}.disposition.type`);
-        if (type === "out_of_scope")
-            fail("out_of_scope_requires_non_goal_or_decision", key(row.key, `${itemLabel}.key`));
-        const claimKey = key(row.key, `${itemLabel}.key`);
-        return {
-            key: claimKey,
-            source_ref: repositorySourceRef(row.source_ref, `${itemLabel}.source_ref`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            disposition: type === "decision_required"
-                ? {
-                    type,
-                    reason: string(disposition.reason, `${itemLabel}.disposition.reason`),
-                }
-                : type === "outcome_result"
-                    ? {
-                        type,
-                        ref: string(disposition.ref, `${itemLabel}.disposition.ref`),
-                    }
-                    : type === "acceptance"
-                        ? {
-                            type,
-                            refs: acceptanceRefs(disposition.refs, `${itemLabel}.disposition.refs`),
-                        }
-                        : {
-                            type,
-                            refs: strings(disposition.refs, `${itemLabel}.disposition.refs`),
-                        },
-            ...(Object.hasOwn(row, "judgment_basis")
-                ? {
-                    judgment_basis: parseSourceClaimJudgmentBasis(row.judgment_basis, `${itemLabel}.judgment_basis`),
-                }
-                : {}),
-        };
-    });
-}
-function parseSourceClaimJudgmentBasis(value, label) {
-    const row = object(value, label, ["kind", "claim_ref", "applicability_refs"]);
-    return {
-        kind: literal(row.kind, ["subjective_preference", "expert_assessment", "authorization"], `${label}.kind`),
-        claim_ref: string(row.claim_ref, `${label}.claim_ref`),
-        applicability_refs: strings(row.applicability_refs, `${label}.applicability_refs`),
-    };
-}
-function acceptanceRefs(value, label) {
-    const refs = strings(value, label);
-    if (refs.length !== 1)
-        fail("source_claim_acceptance_ref_count", label);
-    return [refs[0]];
-}

package/dist/lib/long-task-source-supersession.d.ts

@@ -1,5 +0,0 @@
-import type { CompiledSourceItemV2, MaterialSourceFragmentV2, SemanticFactClassV2, SemanticSourceAnchorV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { ResolvedSourceProjectionV2, SourceConservationFactProjectionV2 } from "./long-task-source-conservation-types.js";
-export declare function validateSameDomainSupersession(projection: ResolvedSourceProjectionV2, material: MaterialSourceFragmentV2 | SemanticSourceAnchorV2, facts: ReadonlyMap<string, SourceConservationFactProjectionV2>, factClasses: Record<string, SemanticFactClassV2>, factDomains: Record<string, SourceAuthorityDomain>, sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>, sourceByKey: ReadonlyMap<string, CompiledSourceItemV2>, manifest: SemanticFactManifestV1): void;
-export declare function validateSameDomainScopeExclusion(projection: ResolvedSourceProjectionV2, material: MaterialSourceFragmentV2 | SemanticSourceAnchorV2, sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>, sourceByKey: ReadonlyMap<string, CompiledSourceItemV2>, manifest: SemanticFactManifestV1): void;

package/dist/lib/long-task-source-supersession.js

@@ -1,138 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSameDomainSupersession(projection, material, facts, factClasses, factDomains, sourceDomains, sourceByKey, manifest) {
-    if (!projection.fact_refs.length)
-        semanticFactClosureInvalid("source_supersession_successor_fact_required", material.key);
-    const oldFactRefs = materialInputFactRefs(material, manifest);
-    if (!oldFactRefs.length)
-        semanticFactClosureInvalid("source_supersession_prior_fact_required", material.key);
-    const oldCells = semanticCells(oldFactRefs, material, facts, factClasses, factDomains);
-    const successorCells = semanticCells(projection.fact_refs, material, facts, factClasses, factDomains);
-    if (!sameSet(oldCells, successorCells))
-        semanticFactClosureInvalid("source_supersession_semantic_cell_mismatch", `${material.key}:${[...oldCells].sort().join(",")}:${[...successorCells]
-            .sort()
-            .join(",")}`);
-    const priorSources = new Set(material.authority_source_item_refs);
-    const supersedingSources = projection.basis_refs
-        .flatMap((ref) => projectionBasisSourceItems(ref, manifest, sourceByKey))
-        .filter((ref) => !priorSources.has(ref));
-    if (!supersedingSources.length)
-        semanticFactClosureInvalid("source_supersession_basis_required", material.key);
-    for (const sourceRef of [...new Set(supersedingSources)]) {
-        if (sourceDomains.get(sourceRef) !== material.authority_domain)
-            semanticFactClosureInvalid("source_supersession_domain_mismatch", `${material.key}:${sourceRef}:${material.authority_domain}:${sourceDomains.get(sourceRef)}`);
-        for (const factRef of projection.fact_refs) {
-            const fact = facts.get(factRef);
-            if (!fact.source_item_refs.includes(sourceRef) ||
-                !hasFactBearingSuccessorFragment(sourceRef, factRef, fact.basis_refs, manifest))
-                semanticFactClosureInvalid("source_supersession_basis_not_fact_bearing", `${material.key}:${sourceRef}:${factRef}`);
-        }
-    }
-}
-export function validateSameDomainScopeExclusion(projection, material, sourceDomains, sourceByKey, manifest) {
-    const exclusions = manifest.scope.exclusions.filter((row) => row.affected_refs.includes(projection.input_key));
-    if (exclusions.length !== 1)
-        semanticFactClosureInvalid(exclusions.length
-            ? "source_projection_scope_exclusion_ambiguous"
-            : "source_projection_scope_exclusion_missing", `${material.key}:${projection.input_key}`);
-    const exclusion = exclusions[0];
-    if (!projection.basis_refs.includes(exclusion.key))
-        semanticFactClosureInvalid("source_scope_exclusion_projection_binding_missing", `${material.key}:${exclusion.key}`);
-    const affectedFactRefs = exactAffectedFactRefs(exclusion.affected_refs, manifest);
-    if (!affectedFactRefs.length)
-        semanticFactClosureInvalid("source_scope_exclusion_exact_obligation_required", `${material.key}:${exclusion.key}`);
-    const materialFactRefs = new Set(materialInputFactRefs(material, manifest));
-    if (affectedFactRefs.some((factRef) => !materialFactRefs.has(factRef)))
-        semanticFactClosureInvalid("source_scope_exclusion_exact_binding_mismatch", `${material.key}:${exclusion.key}:${affectedFactRefs.join(",")}`);
-    const excludedSources = new Set(material.authority_source_item_refs);
-    for (const ref of exclusion.source_item_refs)
-        if (excludedSources.has(ref))
-            semanticFactClosureInvalid("source_scope_exclusion_owner_not_independent", `${material.key}:${ref}`);
-    const owners = exclusion.source_item_refs.filter((ref) => {
-        if (sourceDomains.get(ref) !== material.authority_domain)
-            return false;
-        const item = sourceByKey.get(ref);
-        if (!item || !["decision", "non_goal"].includes(item.kind))
-            return false;
-        const sourceInput = manifest.inputs.find((input) => input.kind === "source_item" && input.source_ref === ref);
-        return affectedFactRefs.every((factRef) => sourceInput?.fact_refs.includes(factRef));
-    });
-    if (!exclusion.source_item_refs.length ||
-        owners.length !== exclusion.source_item_refs.length)
-        semanticFactClosureInvalid("source_scope_exclusion_same_domain_owner_required", `${material.key}:${material.authority_domain}`);
-}
-function materialInputFactRefs(material, manifest) {
-    const inputKey = "input_key" in material
-        ? material.input_key
-        : material.fragment_ref.split("#fragment:", 1)[0];
-    const input = manifest.inputs.find((candidate) => candidate.key === inputKey ||
-        (candidate.kind === "source_item" && candidate.source_ref === inputKey));
-    return input?.fact_refs ?? [];
-}
-function semanticCells(refs, material, facts, factClasses, factDomains) {
-    const result = new Set();
-    for (const factRef of refs) {
-        const fact = facts.get(factRef);
-        if (!fact)
-            semanticFactClosureInvalid("source_supersession_fact_unknown", `${material.key}:${factRef}`);
-        if (factClasses[factRef] !== "delivery_semantic" ||
-            factDomains[factRef] !== material.authority_domain ||
-            !fact.semantic_cell)
-            semanticFactClosureInvalid("source_supersession_delivery_cell_required", `${material.key}:${factRef}`);
-        result.add(semanticCellIdentity(fact.semantic_cell));
-    }
-    return result;
-}
-function semanticCellIdentity(cell) {
-    return [
-        cell.outcome_ref,
-        cell.unit_ref,
-        cell.family_ref,
-        cell.condition_ref,
-        cell.property_ref,
-        cell.value_kind,
-    ].join("\0");
-}
-function sameSet(left, right) {
-    return (left.size === right.size && [...left].every((value) => right.has(value)));
-}
-function projectionBasisSourceItems(ref, manifest, sourceByKey) {
-    if (sourceByKey.has(ref))
-        return [ref];
-    const input = manifest.inputs.find((item) => item.key === ref);
-    if (!input)
-        return [];
-    if (input.kind === "source_item")
-        return [input.source_ref];
-    if (input.kind === "source_fragment" || input.kind === "semantic_anchor") {
-        const inputKey = input.source_ref.split("#fragment:", 1)[0];
-        if (sourceByKey.has(inputKey))
-            return [inputKey];
-        const materialInput = manifest.inputs.find((item) => item.key === inputKey);
-        if (!materialInput)
-            return [];
-        return materialInput.basis_refs.filter((basisRef) => sourceByKey.has(basisRef));
-    }
-    return input.basis_refs.filter((basisRef) => sourceByKey.has(basisRef));
-}
-function hasFactBearingSuccessorFragment(sourceRef, factRef, factBasisRefs, manifest) {
-    return manifest.inputs.some((input) => input.kind === "source_fragment" &&
-        input.source_ref.startsWith(`${sourceRef}#fragment:`) &&
-        input.disposition === "fact_bearing" &&
-        input.fact_refs.includes(factRef) &&
-        factBasisRefs.includes(input.key));
-}
-function exactAffectedFactRefs(refs, manifest) {
-    const facts = new Set(manifest.facts.map((fact) => fact.key));
-    const result = new Set();
-    for (const ref of refs) {
-        if (facts.has(ref))
-            result.add(ref);
-        const cell = manifest.fact_cells.find((candidate) => candidate.key === ref);
-        if (cell?.fact_ref)
-            result.add(cell.fact_ref);
-        const proof = manifest.proof_obligations.find((candidate) => candidate.key === ref);
-        if (proof)
-            result.add(proof.fact_ref);
-    }
-    return [...result].sort();
-}

package/dist/lib/long-task-source-target-continuity.d.ts

@@ -1,4 +0,0 @@
-import type { CompiledSourceItemV2, DeliveryContractV2, SourceBackedExecutionTargetV2 } from "./long-task-delivery-types.js";
-type ValidationReporter = (message: string) => void;
-export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): Map<string, SourceBackedExecutionTargetV2>;
-export {};

package/dist/lib/long-task-source-target-continuity.js

@@ -1,141 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { buildCanonicalSourceTargetIndex, executionTargetSourceTargetRef, sourceKindForTarget, } from "./long-task-source-target-index.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function validateSourceTargetContinuity(contract, items, report) {
-    const state = sourceContinuityState(contract, items);
-    for (const claim of contract.source_claims)
-        validateSourceClaimContinuity(claim, state, report);
-    validateAcceptanceBindingContinuity(contract, state, report);
-    validateArchitectureContinuity(state, report);
-    validateRequiredExecutionTargetContinuity(contract, state, report);
-    return state.executionTargetAuthorities;
-}
-function sourceContinuityState(contract, items) {
-    return {
-        itemByKey: new Map(items.map((item) => [item.key, item])),
-        targets: buildCanonicalSourceTargetIndex(contract),
-        owners: new Map(),
-        sourceBackedOutcomeClaims: new Set(),
-        sourceBackedGlobalClaims: new Set(),
-        acceptanceBindings: [],
-        architectureItems: new Set(items
-            .filter((item) => item.aspect === "architecture")
-            .map((item) => item.key)),
-        ownedArchitectureItems: new Set(),
-        executionTargetAuthorities: new Map(),
-    };
-}
-function validateSourceClaimContinuity(claim, state, report) {
-    const item = state.itemByKey.get(claim.key);
-    if (!item || claim.disposition.type === "decision_required")
-        return;
-    const refs = dispositionRefs(claim.disposition);
-    if (refs.length !== 1) {
-        issue(report, `source_claim_target_ref_count:${claim.key}:${refs.length}`);
-        return;
-    }
-    const ref = refs[0];
-    const target = state.targets.get(ref);
-    if (!target ||
-        (target.kind !== "semantic_fact" &&
-            sourceKindForTarget(target) !== item.kind)) {
-        issue(report, `source_target_kind_mismatch:${claim.key}:${item.kind}:${target ? sourceKindForTarget(target) : "unknown"}:${ref}`);
-        return;
-    }
-    if (item.kind === "risk_fact" &&
-        (target.risk_fact !== item.risk_semantics?.fact ||
-            target.affected_outcome !== item.risk_semantics?.affected_outcome)) {
-        issue(report, `source_risk_target_mismatch:${claim.key}:${item.risk_semantics?.fact ?? "missing"}:${item.risk_semantics?.affected_outcome ?? "missing"}:${ref}`);
-        return;
-    }
-    if (target.normalized_text !== undefined &&
-        target.normalized_text !== item.normalized_text) {
-        issue(report, target.execution_target_ref
-            ? `process_root_source_identity_mismatch:${target.execution_target_ref}:${claim.key}`
-            : `source_target_statement_mismatch:${claim.key}:${ref}`);
-        return;
-    }
-    const owner = state.owners.get(ref);
-    if (owner) {
-        issue(report, `source_target_already_owned:${claim.key}:${ref}:${owner}`);
-        return;
-    }
-    state.owners.set(ref, claim.key);
-    if (state.architectureItems.has(item.key) &&
-        target.kind === "technical_obligation")
-        state.ownedArchitectureItems.add(item.key);
-    if (target.outcome_key &&
-        [
-            "requirement",
-            "control",
-            "technical_obligation",
-            "non_completing",
-            "forbidden_shortcut",
-            "semantic_fact",
-        ].includes(target.kind))
-        state.sourceBackedOutcomeClaims.add(ref);
-    if (!target.outcome_key &&
-        ["global_constraint", "non_goal", "forbidden_shortcut"].includes(target.kind))
-        state.sourceBackedGlobalClaims.add(ref);
-    if (target.kind === "acceptance")
-        state.acceptanceBindings.push({ claim, target });
-    if (target.execution_target_ref)
-        state.executionTargetAuthorities.set(target.execution_target_ref, {
-            target_ref: target.execution_target_ref,
-            canonical_target_ref: ref,
-            source_claim_key: claim.key,
-            source_item_key: item.key,
-            source_path: item.source_path,
-            source_text_sha256: item.text_sha256,
-            target_identity: sha256Hex(canonicalValueJson({
-                canonical_target_ref: ref,
-                source_claim_key: claim.key,
-                source_item_key: item.key,
-                source_path: item.source_path,
-                source_text_sha256: item.text_sha256,
-                normalized_text: item.normalized_text,
-            })),
-        });
-}
-function validateRequiredExecutionTargetContinuity(contract, state, report) {
-    for (const targetRef of contract.task.target_profile.required_target_refs) {
-        if (state.executionTargetAuthorities.has(targetRef))
-            continue;
-        const target = contract.task.execution_targets.find((candidate) => candidate.key === targetRef);
-        issue(report, target?.runtime_family === "process"
-            ? `process_root_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`
-            : `execution_target_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`);
-    }
-}
-function validateAcceptanceBindingContinuity(contract, state, report) {
-    for (const { claim, target } of state.acceptanceBindings) {
-        const resolved = resolveAcceptanceAssertion(contract, target.ref);
-        const sourceBacked = resolved?.scope === "outcome" && target.outcome_key
-            ? resolved.assertion.claims.some((localKey) => localKey !== "result" &&
-                state.sourceBackedOutcomeClaims.has(`${target.outcome_key}.${localKey}`))
-            : resolved?.scope === "global"
-                ? resolved.assertion.claims.some((localKey) => state.sourceBackedGlobalClaims.has(localKey))
-                : false;
-        if (!sourceBacked)
-            issue(report, `source_acceptance_without_source_backed_claim:${claim.key}:${target.ref}`);
-    }
-}
-function validateArchitectureContinuity(state, report) {
-    if (!state.architectureItems.size)
-        issue(report, "source_architecture_obligation_required");
-    for (const key of state.architectureItems)
-        if (!state.ownedArchitectureItems.has(key))
-            issue(report, `source_architecture_obligation_unmapped:${key}`);
-}
-function dispositionRefs(disposition) {
-    if (disposition.type === "decision_required")
-        return [];
-    if (disposition.type === "outcome_result")
-        return [disposition.ref];
-    return disposition.refs;
-}
-function issue(report, message) {
-    if (!report)
-        throw new Error(message);
-    report(message);
-}

package/dist/lib/long-task-source-target-index.d.ts

@@ -1,15 +0,0 @@
-import type { DeliveryContractV2, SourceItemKind } from "./long-task-delivery-types.js";
-export interface CanonicalSourceTarget {
-    ref: string;
-    kind: "outcome_result" | "requirement" | "control" | "technical_obligation" | "non_completing" | "global_constraint" | "non_goal" | "forbidden_shortcut" | "acceptance" | "semantic_fact" | "risk_fact" | "external_confirmation";
-    normalized_text?: string;
-    scope?: "global" | "outcome";
-    outcome_key?: string;
-    risk_fact?: keyof DeliveryContractV2["risk"]["facts"];
-    affected_outcome?: string;
-    execution_target_ref?: string;
-}
-export declare function buildCanonicalSourceTargetIndex(contract: DeliveryContractV2): Map<string, CanonicalSourceTarget>;
-export declare function executionTargetSourceTargetRef(targetKey: string): string;
-export declare function executionTargetSourceStatement(targetValue: DeliveryContractV2["task"]["execution_targets"][number]): string;
-export declare function sourceKindForTarget(target: CanonicalSourceTarget): SourceItemKind | null;

package/dist/lib/long-task-source-target-index.js

@@ -1,91 +0,0 @@
-import { controlFieldFacts } from "./long-task-control-fields.js";
-import { normalizeSourceItemText } from "./long-task-source-item-parser.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function buildCanonicalSourceTargetIndex(contract) {
-    const targets = [];
-    for (const executionTarget of contract.task.execution_targets)
-        targets.push({
-            ...target(executionTargetSourceTargetRef(executionTarget.key), "technical_obligation", executionTargetSourceStatement(executionTarget)),
-            execution_target_ref: executionTarget.key,
-        });
-    for (const outcome of contract.outcomes) {
-        targets.push(target(`${outcome.key}.result`, "outcome_result", outcome.product.observable_result, outcome.key));
-        for (const requirement of outcome.product.requirements)
-            targets.push(target(`${outcome.key}.requirement.${requirement.key}`, "requirement", requirement.statement, outcome.key));
-        for (const binding of outcome.semantic_fact_bindings.facts)
-            targets.push(target(`${outcome.key}.${binding.claim_ref}`, "semantic_fact", undefined, outcome.key));
-        for (const control of outcome.product.controls)
-            for (const field of controlFieldFacts(control))
-                targets.push(target(`${outcome.key}.control.${control.key}.${field.claim_field}`, "control", field.statement, outcome.key));
-        if (outcome.product.control_relation_closure.state !== "unresolved")
-            targets.push(target(`${outcome.key}.control_relation_closure`, "control", outcome.product.control_relation_closure.statement, outcome.key));
-        for (const relation of outcome.product.control_relations)
-            targets.push(target(`${outcome.key}.control_relation.${relation.key}`, "control", relation.statement, outcome.key));
-        for (const obligation of outcome.technical.obligations)
-            targets.push(target(`${outcome.key}.obligation.${obligation.key}`, "technical_obligation", obligation.statement, outcome.key));
-        for (const item of outcome.product.non_completing_outcomes)
-            targets.push(target(`${outcome.key}.non_completing.${item.key}`, "non_completing", item.statement, outcome.key));
-        for (const shortcut of outcome.technical.forbidden_shortcuts)
-            targets.push(target(`${outcome.key}.forbidden_shortcut.${shortcut.key}`, "forbidden_shortcut", shortcut.statement, outcome.key));
-        for (const check of outcome.acceptance.checks)
-            for (const assertion of [
-                ...check.positive_assertions,
-                ...check.negative_assertions,
-            ])
-                targets.push(target(`${outcome.key}.${check.key}.${assertion.key}`, "acceptance", assertion.criterion, outcome.key, "outcome"));
-    }
-    for (const item of contract.global.product.non_goals)
-        targets.push(target(`non_goal.${item.key}`, "non_goal", item.statement));
-    for (const item of contract.global.technical.constraints)
-        targets.push(target(`constraint.${item.key}`, "global_constraint", item.statement));
-    for (const item of contract.global.technical.forbidden_shortcuts)
-        targets.push(target(`forbidden_shortcut.${item.key}`, "forbidden_shortcut", item.statement));
-    for (const check of contract.global.acceptance.checks)
-        for (const assertion of [
-            ...check.positive_assertions,
-            ...check.negative_assertions,
-        ])
-            targets.push(target(`GLOBAL.${check.key}.${assertion.key}`, "acceptance", assertion.criterion, undefined, "global"));
-    for (const [fact, outcomes] of Object.entries(contract.risk.facts))
-        for (const outcome of outcomes)
-            targets.push({
-                ref: `${fact}:${outcome}`,
-                kind: "risk_fact",
-                risk_fact: fact,
-                affected_outcome: outcome,
-            });
-    for (const item of contract.global.acceptance.external_confirmations)
-        targets.push(target(item.key, "external_confirmation", item.description));
-    return new Map(targets.map((item) => [item.ref, item]));
-}
-export function executionTargetSourceTargetRef(targetKey) {
-    return `execution_target.${targetKey}`;
-}
-export function executionTargetSourceStatement(targetValue) {
-    return `Execution target authority: ${canonicalValueJson({
-        key: targetValue.key,
-        role: targetValue.role,
-        runtime_family: targetValue.runtime_family,
-        root_entrypoint: targetValue.root_entrypoint,
-        root_argv: [...(targetValue.root_argv ?? [])],
-        capabilities: [...new Set(targetValue.capabilities)].sort(),
-    })}.`;
-}
-function target(ref, kind, text, outcomeKey, scope) {
-    return {
-        ref,
-        kind,
-        ...(text !== undefined
-            ? { normalized_text: normalizeSourceItemText(text) }
-            : {}),
-        ...(outcomeKey ? { outcome_key: outcomeKey } : {}),
-        ...(scope ? { scope } : {}),
-    };
-}
-export function sourceKindForTarget(target) {
-    return target.kind === "global_constraint"
-        ? "technical_obligation"
-        : target.kind === "semantic_fact"
-            ? null
-            : target.kind;
-}

package/dist/lib/long-task-source-validation.d.ts

@@ -1,3 +0,0 @@
-import type { SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function validateSourceAnchors(repository: string, sourceClaims: SourceClaimV2[]): Promise<void>;
-export declare function markdownAnchors(content: string): Set<string>;

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

@@ -1,46 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-export async function validateSourceAnchors(repository, sourceClaims) {
-    const anchorsByFile = new Map();
-    for (const [index, claim] of sourceClaims.entries()) {
-        const [relative, anchor] = claim.source_ref.split("#");
-        if (!anchor)
-            continue;
-        let anchors = anchorsByFile.get(relative);
-        if (!anchors) {
-            const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), `source[${index}]`);
-            anchors = markdownAnchors(await readFile(file, "utf8"));
-            anchorsByFile.set(relative, anchors);
-        }
-        if (!anchors.has(anchor))
-            throw new Error(`source_claim_anchor_not_found:${claim.key}:${claim.source_ref}`);
-    }
-}
-export function markdownAnchors(content) {
-    const anchors = new Set();
-    const slugCounts = new Map();
-    for (const line of content.split(/\r?\n/u)) {
-        const heading = /^(?: {0,3})#{1,6}\s+(.+?)\s*#*\s*$/u.exec(line);
-        if (heading) {
-            const base = githubSlug(heading[1]);
-            if (base) {
-                const count = slugCounts.get(base) ?? 0;
-                anchors.add(count === 0 ? base : `${base}-${count}`);
-                slugCounts.set(base, count + 1);
-            }
-        }
-        for (const match of line.matchAll(/(?:\{#([A-Za-z0-9._:-]+)\}|(?:id|name)=["']([^"']+)["'])/gu))
-            anchors.add(match[1] ?? match[2]);
-    }
-    return anchors;
-}
-function githubSlug(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/<[^>]*>/gu, "")
-        .replace(/[^\p{L}\p{N}\s_-]/gu, "")
-        .replace(/\s+/gu, "-")
-        .replace(/-+/gu, "-");
-}

package/dist/lib/long-task-stage-policy.d.ts

@@ -1,9 +0,0 @@
-import type { CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-type Reporter = (message: string) => void;
-export declare function validateDeliveryStages(contract: DeliveryContractV2, report?: Reporter, options?: {
-    defer_completion_authority_closure?: boolean;
-    acceptance_reachability?: AcceptanceReachabilityV1 | null;
-    compiled_outcomes?: readonly CompiledOutcomeV2[];
-}): void;
-export {};