project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,135 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { fail } from "./long-task-delivery-shape.js";
-import { executionTargetSourceTargetRef } from "./long-task-source-target-index.js";
-export function validateSourceClaimMappings(contract, compiledClaims, report) {
-    validateSourcePresence(contract, report);
-    const sources = new Set(contract.task.source_paths);
-    const productClaims = new Set(Object.values(compiledClaims.by_outcome)
-        .flat()
-        .map((claim) => claim.id));
-    const claimApplicability = new Map([
-        ...compiledClaims.by_global,
-        ...Object.values(compiledClaims.by_outcome).flat(),
-    ].map((claim) => [claim.id, new Set(claim.applicability_refs)]));
-    const executionTargetClaims = new Set(contract.task.execution_targets.map((target) => executionTargetSourceTargetRef(target.key)));
-    const globalClaims = new Map(compiledClaims.by_global.map((claim) => [claim.local_key, claim]));
-    const coveredGlobalClaims = new Set(Object.entries(compiledClaims.summary.claims_by_global)
-        .filter(([, value]) => value.covered)
-        .map(([key]) => key));
-    const forbiddenPaths = new Set(contract.global.technical.forbidden_paths.map((item) => `forbidden_path.${item.key}`));
-    const outcomeResults = new Set(contract.outcomes.map((outcome) => `${outcome.key}.result`));
-    const externalConfirmations = new Set(contract.global.acceptance.external_confirmations.map((item) => item.key));
-    for (const claim of contract.source_claims) {
-        validateSourceReference(claim.key, claim.source_ref, sources, report);
-        const disposition = claim.disposition;
-        if ("refs" in disposition && !disposition.refs.length)
-            issue(report, "source_claim_disposition_refs_empty", claim.key);
-        if (disposition.type === "claim")
-            for (const reference of disposition.refs) {
-                if (reference.endsWith(".result"))
-                    issue(report, "source_claim_result_overcompression", `${claim.key}:${reference}`);
-                if (!productClaims.has(reference) &&
-                    !executionTargetClaims.has(reference))
-                    issue(report, "source_claim_product_ref_unknown", `${claim.key}:${reference}`);
-            }
-        if (disposition.type === "acceptance") {
-            if (disposition.refs.length !== 1)
-                issue(report, "source_claim_acceptance_ref_count", claim.key);
-            const reference = disposition.refs[0];
-            const resolved = resolveAcceptanceAssertion(contract, reference);
-            if (!resolved)
-                issue(report, "source_claim_acceptance_ref_unknown", `${claim.key}:${reference}`);
-            else if (resolved.scope === "outcome" &&
-                (!resolved.assertion.claims.length ||
-                    resolved.assertion.claims.every((item) => item === "result")))
-                issue(report, "source_claim_acceptance_result_only", `${claim.key}:${reference}`);
-            else if (resolved.scope === "global" && !resolved.assertion.claims.length)
-                issue(report, "source_claim_acceptance_global_claim_required", `${claim.key}:${reference}`);
-        }
-        if (disposition.type === "outcome_result" &&
-            !outcomeResults.has(disposition.ref))
-            issue(report, "source_claim_outcome_result_ref_unknown", `${claim.key}:${disposition.ref}`);
-        if (disposition.type === "external_confirmation")
-            validateRefs(claim.key, disposition.refs, externalConfirmations, "source_claim_external_confirmation_ref_unknown", report);
-        if (disposition.type === "global_constraint")
-            validateGlobalRefs(claim.key, disposition.refs, forbiddenPaths, globalClaims, coveredGlobalClaims, report);
-        if (disposition.type === "risk_fact")
-            validateRiskRefs(contract, claim.key, disposition.refs, report);
-        validateJudgmentBasis(contract, claim, claimApplicability, report);
-    }
-}
-function validateJudgmentBasis(contract, claim, claimApplicability, report) {
-    const basis = claim.judgment_basis;
-    if (!basis)
-        return;
-    if (!sourceClaimOwnsClaim(contract, claim, basis))
-        issue(report, "source_claim_judgment_basis_claim_not_owned", `${claim.key}:${basis.claim_ref}`);
-    const applicability = claimApplicability.get(basis.claim_ref);
-    if (!applicability)
-        issue(report, "source_claim_judgment_basis_claim_unknown", `${claim.key}:${basis.claim_ref}`);
-    if (!basis.applicability_refs.length ||
-        new Set(basis.applicability_refs).size !== basis.applicability_refs.length)
-        issue(report, "source_claim_judgment_basis_applicability_set_invalid", claim.key);
-    for (const applicabilityRef of basis.applicability_refs)
-        if (!applicability?.has(applicabilityRef))
-            issue(report, "source_claim_judgment_basis_applicability_unknown", `${claim.key}:${basis.claim_ref}:${applicabilityRef}`);
-}
-function sourceClaimOwnsClaim(contract, claim, basis) {
-    const disposition = claim.disposition;
-    if (disposition.type === "claim" || disposition.type === "global_constraint")
-        return disposition.refs.includes(basis.claim_ref);
-    if (disposition.type === "outcome_result")
-        return disposition.ref === basis.claim_ref;
-    if (disposition.type !== "external_confirmation")
-        return false;
-    return basis.applicability_refs.every((applicabilityRef) => contract.global.acceptance.external_confirmations.some((confirmation) => disposition.refs.includes(confirmation.key) &&
-        confirmation.obligations?.some((obligation) => obligation.claim_ref === basis.claim_ref &&
-            obligation.applicability_ref === applicabilityRef &&
-            obligation.result_kind === "judgment" &&
-            obligation.judgment_basis?.kind === basis.kind &&
-            obligation.judgment_basis.source_ref === claim.key)));
-}
-function validateSourcePresence(contract, report) {
-    if (!contract.task.source_paths.length || !contract.source_claims.length)
-        issue(report, "source_authority_required", "source_paths and source_claims must be non-empty");
-}
-function validateRiskRefs(contract, claimKey, refs, report) {
-    for (const reference of refs) {
-        const separator = reference.indexOf(":");
-        const fact = reference.slice(0, separator);
-        const outcome = reference.slice(separator + 1);
-        if (separator <= 0 ||
-            !outcome ||
-            !Object.hasOwn(contract.risk.facts, fact) ||
-            !contract.risk.facts[fact].includes(outcome))
-            issue(report, "source_claim_risk_fact_ref_unknown", `${claimKey}:${reference}`);
-    }
-}
-function validateSourceReference(key, sourceRef, sources, report) {
-    const [sourceFile, anchor, ...extra] = sourceRef.split("#");
-    if (!sourceFile || extra.length || (anchor !== undefined && !anchor))
-        issue(report, "source_claim_ref_invalid", `${key}:${sourceRef}`);
-    if (!sources.has(sourceFile))
-        issue(report, "source_claim_ref_unknown", `${key}:${sourceRef}`);
-}
-function validateRefs(claimKey, refs, known, code, report) {
-    for (const reference of refs)
-        if (!known.has(reference))
-            issue(report, code, `${claimKey}:${reference}`);
-}
-function validateGlobalRefs(claimKey, refs, forbiddenPaths, globalClaims, coveredGlobalClaims, report) {
-    for (const reference of refs)
-        if (reference.startsWith("forbidden_path.")) {
-            if (!forbiddenPaths.has(reference))
-                issue(report, "source_claim_global_ref_unknown", `${claimKey}:${reference}`);
-        }
-        else if (!globalClaims.has(reference))
-            issue(report, "source_claim_global_ref_unknown", `${claimKey}:${reference}`);
-        else if (!coveredGlobalClaims.has(reference))
-            issue(report, "source_claim_global_ref_uncovered", `${claimKey}:${reference}`);
-}
-function issue(report, code, detail) {
-    if (!report)
-        fail(code, detail);
-    report(`delivery_contract_invalid:${code}:${detail}`);
-}

package/dist/lib/long-task-source-conservation-facts.d.ts

@@ -1,8 +0,0 @@
-import type { SemanticFactClassV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { SourceConservationFactProjectionV2 } from "./long-task-source-conservation-types.js";
-export declare function addSourceConservationFact(facts: Map<string, SourceConservationFactProjectionV2>, fact: SourceConservationFactProjectionV2): void;
-export declare function semanticFactClass(fact: SemanticFactManifestV1["facts"][number]): SemanticFactClassV2;
-export declare function semanticFactAuthorityDomain(fact: SemanticFactManifestV1["facts"][number], sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>): SourceAuthorityDomain;
-export declare function semanticExpectedContains(fact: SourceConservationFactProjectionV2, value: string): boolean;
-export declare function semanticFactExpectedSearchText(fact: SemanticFactManifestV1["facts"][number]): string;

package/dist/lib/long-task-source-conservation-facts.js

@@ -1,57 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-export function addSourceConservationFact(facts, fact) {
-    if (facts.has(fact.key))
-        semanticFactClosureInvalid("source_projection_fact_duplicate", fact.key);
-    facts.set(fact.key, fact);
-}
-export function semanticFactClass(fact) {
-    const structuralLocator = [
-        "source_item",
-        "whole_resource",
-        "code_symbol",
-    ].includes(fact.expected.locator.kind);
-    return fact.observation_scope === "implementation_structure" &&
-        (fact.value_kind === "digest" ||
-            fact.expected.representation === "digest_only" ||
-            structuralLocator)
-        ? "source_integrity"
-        : "delivery_semantic";
-}
-export function semanticFactAuthorityDomain(fact, sourceDomains) {
-    const available = new Set(fact.source_item_refs
-        .map((ref) => sourceDomains.get(ref))
-        .filter((value) => Boolean(value)));
-    if (available.size === 1)
-        return [...available][0];
-    const preferred = fact.observation_scope === "external_boundary"
-        ? "external"
-        : fact.observation_scope === "product_boundary"
-            ? "product"
-            : "technical";
-    if (available.has(preferred))
-        return preferred;
-    for (const candidate of [
-        "acceptance",
-        "product",
-        "technical",
-        "external",
-        "design",
-    ])
-        if (available.has(candidate))
-            return candidate;
-    semanticFactClosureInvalid("fact_authority_domain_missing", fact.key);
-}
-export function semanticExpectedContains(fact, value) {
-    return fact.expected_search_text.includes(value);
-}
-export function semanticFactExpectedSearchText(fact) {
-    return [
-        fact.expected.representation === "inline"
-            ? JSON.stringify(fact.expected.value)
-            : "",
-        fact.expected.locator.value,
-        fact.property_ref,
-        fact.unit_ref,
-        fact.owner_ref,
-    ].join("\n");
-}

package/dist/lib/long-task-source-conservation-types.d.ts

@@ -1,34 +0,0 @@
-import type { MaterialSourceFragmentV2, SemanticFactClassV2, SemanticSourceAnchorV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
-import type { SemanticFactSupportingRelationV1 } from "./semantic-fact-inventory-types.js";
-export type SourceProjectionDispositionV2 = "fact_bearing" | "supporting_basis" | "superseded" | "decision_required" | "scope_excluded";
-export interface ResolvedSourceProjectionV2 {
-    input_key: string;
-    disposition: SourceProjectionDispositionV2;
-    fact_refs: string[];
-    basis_refs: string[];
-    supporting_relation?: SemanticFactSupportingRelationV1;
-    explicit: boolean;
-    authority_derived: boolean;
-}
-export interface SourceConservationFactProjectionV2 {
-    key: string;
-    source_item_refs: string[];
-    basis_refs: string[];
-    semantic_class: SemanticFactClassV2;
-    authority_domain: SourceAuthorityDomain;
-    expected_search_text: string;
-    semantic_cell: {
-        outcome_ref: string;
-        unit_ref: string;
-        family_ref: string;
-        condition_ref: string;
-        property_ref: string;
-        value_kind: string;
-    } | null;
-}
-export interface SourceSemanticConservationV2 {
-    fragments: MaterialSourceFragmentV2[];
-    anchors: SemanticSourceAnchorV2[];
-    fact_classes: Record<string, SemanticFactClassV2>;
-    fact_domains: Record<string, SourceAuthorityDomain>;
-}

package/dist/lib/long-task-source-conservation-types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,7 +0,0 @@
-import type { CompiledSourceItemV2, MaterialTextInputV2 } from "./long-task-source-authority-types.js";
-import type { DesignOwnedSemanticProjectionV1 } from "./long-task-semantic-fact-input-closure.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { SourceSemanticConservationV2 } from "./long-task-source-conservation-types.js";
-export type { SourceSemanticConservationV2 } from "./long-task-source-conservation-types.js";
-export { semanticFactAuthorityDomain, semanticFactClass, } from "./long-task-source-conservation-facts.js";
-export declare function validateSourceSemanticConservation(sourceItems: CompiledSourceItemV2[], manifest: SemanticFactManifestV1, designInput: Set<string> | DesignOwnedSemanticProjectionV1, materialInput?: MaterialTextInputV2[], factClaimPolarities?: ReadonlyMap<string, ReadonlySet<"positive" | "negative">>): SourceSemanticConservationV2;

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

@@ -1,110 +0,0 @@
-import { deriveSemanticSourceAnchors, scanMaterialTextInput, sourceAuthorityDomain, } from "./long-task-source-fragments.js";
-import { addSourceConservationFact, semanticFactAuthorityDomain, semanticFactClass, semanticFactExpectedSearchText, } from "./long-task-source-conservation-facts.js";
-import { resolveFragmentProjection } from "./long-task-source-projection-resolution.js";
-import { validateAnchorProjection, validateNoDanglingProjectionInputs, validateProjection, } from "./long-task-source-projection-validation.js";
-export { semanticFactAuthorityDomain, semanticFactClass, } from "./long-task-source-conservation-facts.js";
-export function validateSourceSemanticConservation(sourceItems, manifest, designInput, materialInput, factClaimPolarities = new Map()) {
-    const designProjection = designInput instanceof Set
-        ? { source_items: designInput, facts: [] }
-        : designInput;
-    const designOwnedSourceItems = designProjection.source_items;
-    const sourceByKey = new Map(sourceItems.map((item) => [item.key, item]));
-    const sourceDomains = sourceAuthorityDomains(sourceItems, designOwnedSourceItems);
-    const facts = sourceConservationFacts(manifest, designProjection, sourceDomains);
-    const factClasses = Object.fromEntries([...facts.values()].map((fact) => [fact.key, fact.semantic_class]));
-    const factDomains = Object.fromEntries([...facts.values()].map((fact) => [fact.key, fact.authority_domain]));
-    const designFactRefsBySource = designFactsBySource(designProjection);
-    const materialInputs = materialInput ??
-        sourceItems.map((item) => ({
-            input_key: item.key,
-            input_kind: "source_item",
-            source_ref: item.source_path,
-            sha256: item.text_sha256,
-            authority_source_item_refs: [item.key],
-            authority_domain: sourceAuthorityDomain(item, designOwnedSourceItems.has(item.key)),
-            normalized_text: item.normalized_text,
-        }));
-    const fragments = materialInputs.flatMap((input) => scanMaterialTextInput(input).fragments);
-    const anchors = [];
-    const validationContext = {
-        facts,
-        factClasses,
-        factDomains,
-        sourceDomains,
-        sourceByKey,
-        manifest,
-        designFactRefsBySource,
-        factClaimPolarities,
-    };
-    for (const material of materialInputs) {
-        const itemFragments = fragments.filter((fragment) => fragment.input_key === material.input_key);
-        for (const fragment of itemFragments) {
-            const projection = resolveFragmentProjection(fragment, manifest);
-            validateProjection(projection, fragment, validationContext);
-            const fragmentAnchors = deriveSemanticSourceAnchors(fragment);
-            anchors.push(...fragmentAnchors);
-            for (const anchor of fragmentAnchors)
-                validateAnchorProjection(anchor, projection, validationContext);
-        }
-    }
-    validateNoDanglingProjectionInputs(fragments, anchors, manifest);
-    return {
-        fragments: fragments.sort((left, right) => left.key.localeCompare(right.key)),
-        anchors: anchors.sort((left, right) => left.key.localeCompare(right.key)),
-        fact_classes: factClasses,
-        fact_domains: factDomains,
-    };
-}
-function sourceAuthorityDomains(sourceItems, designOwned) {
-    return new Map(sourceItems.map((item) => [
-        item.key,
-        sourceAuthorityDomain(item, designOwned.has(item.key)),
-    ]));
-}
-function sourceConservationFacts(manifest, designProjection, sourceDomains) {
-    const facts = new Map();
-    for (const fact of manifest.facts)
-        addSourceConservationFact(facts, {
-            key: fact.key,
-            source_item_refs: fact.source_item_refs,
-            basis_refs: fact.provenance.basis_refs,
-            semantic_class: semanticFactClass(fact),
-            authority_domain: semanticFactAuthorityDomain(fact, sourceDomains),
-            expected_search_text: semanticFactExpectedSearchText(fact),
-            semantic_cell: {
-                outcome_ref: fact.outcome_ref,
-                unit_ref: fact.unit_ref,
-                family_ref: fact.family_ref,
-                condition_ref: fact.condition_ref,
-                property_ref: fact.property_ref,
-                value_kind: fact.value_kind,
-            },
-        });
-    for (const fact of designProjection.facts)
-        addSourceConservationFact(facts, {
-            ...fact,
-            basis_refs: [
-                ...new Set([
-                    ...fact.basis_refs,
-                    ...manifest.inputs
-                        .filter((input) => input.kind === "source_fragment" &&
-                        input.fact_refs.includes(fact.key))
-                        .map((input) => input.key),
-                ]),
-            ],
-            semantic_class: "delivery_semantic",
-            authority_domain: "design",
-            semantic_cell: null,
-        });
-    return facts;
-}
-function designFactsBySource(designProjection) {
-    const result = new Map();
-    for (const fact of designProjection.facts)
-        for (const sourceRef of fact.source_item_refs) {
-            const refs = result.get(sourceRef) ?? [];
-            refs.push(fact.key);
-            result.set(sourceRef, refs);
-        }
-    return result;
-}

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

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

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

@@ -1,57 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { normalizeSourceItemText } from "./long-task-source-item-parser.js";
-export function validateSourceContinuity(contract, items, report) {
-    const itemByKey = new Map(items.map((item) => [item.key, item]));
-    const claimByKey = new Map(contract.source_claims.map((claim) => [claim.key, claim]));
-    for (const claim of contract.source_claims) {
-        const item = itemByKey.get(claim.key);
-        if (!item) {
-            issue(report, `source_claim_item_unknown:${claim.key}`);
-            continue;
-        }
-        const sourcePath = claim.source_ref.split("#")[0];
-        if (sourcePath !== item.source_path)
-            issue(report, `source_claim_item_file_mismatch:${claim.key}:${sourcePath}:${item.source_path}`);
-        if (normalizeSourceItemText(claim.statement) !== item.normalized_text)
-            issue(report, `source_claim_statement_mismatch:${claim.key}`);
-        validateDispositionKind(claim, item.kind, report);
-        if (claim.disposition.type === "acceptance") {
-            const resolved = resolveAcceptanceAssertion(contract, claim.disposition.refs[0]);
-            if (!resolved?.assertion.criterion ||
-                normalizeSourceItemText(resolved.assertion.criterion) !==
-                    item.normalized_text)
-                issue(report, `source_acceptance_criterion_mismatch:${claim.key}`);
-        }
-    }
-    for (const item of items)
-        if (!claimByKey.has(item.key))
-            issue(report, `source_item_unmapped:${item.key}`);
-}
-function validateDispositionKind(claim, kind, report) {
-    const allowed = new Set(kind === "outcome_result"
-        ? ["outcome_result"]
-        : kind === "technical_obligation"
-            ? ["claim", "global_constraint"]
-            : kind === "requirement" ||
-                kind === "control" ||
-                kind === "non_completing"
-                ? ["claim"]
-                : kind === "acceptance"
-                    ? ["acceptance"]
-                    : kind === "non_goal"
-                        ? ["global_constraint"]
-                        : kind === "forbidden_shortcut"
-                            ? ["claim", "global_constraint"]
-                            : kind === "risk_fact"
-                                ? ["risk_fact"]
-                                : kind === "external_confirmation"
-                                    ? ["external_confirmation"]
-                                    : ["decision_required"]);
-    if (!allowed.has(claim.disposition.type))
-        issue(report, `source_item_disposition_mismatch:${claim.key}:${kind}:${claim.disposition.type}`);
-}
-function issue(report, message) {
-    if (!report)
-        throw new Error(message);
-    report(message);
-}

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

@@ -1,6 +0,0 @@
-import type { CompiledSourceItemV2, MaterialFragmentScanResultV2, MaterialSourceFragmentV2, MaterialTextInputV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
-export { deriveSemanticSourceAnchors, semanticSourceAnchorRef, } from "./long-task-source-anchors.js";
-export declare function sourceAuthorityDomain(item: CompiledSourceItemV2, designOwned: boolean): SourceAuthorityDomain;
-export declare function materialSourceFragmentRef(fragment: Pick<MaterialSourceFragmentV2, "input_key" | "ordinal" | "text_sha256">): string;
-export declare function deriveMaterialSourceFragments(item: CompiledSourceItemV2, designOwned?: boolean): MaterialSourceFragmentV2[];
-export declare function scanMaterialTextInput(input: MaterialTextInputV2): MaterialFragmentScanResultV2;

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

@@ -1,219 +0,0 @@
-import { sha256Hex } from "./strict-codec.js";
-export { deriveSemanticSourceAnchors, semanticSourceAnchorRef, } from "./long-task-source-anchors.js";
-const FENCE_START = /^\s*(`{3,}|~{3,})([^`]*)$/u;
-const TABLE_ROW = /^\s*\|.*\|\s*$/u;
-const TABLE_SEPARATOR = /^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*:?-{3,}:?\s*\|?\s*$/u;
-const MARKDOWN_SEPARATOR = /^\s{0,3}((?:-\s*){3,}|(?:\*\s*){3,}|(?:_\s*){3,})$/u;
-const HEADING = /^\s{0,3}#{1,6}(?:\s+\S|\s*$)/u;
-const BLOCKQUOTE = /^\s{0,3}>/u;
-const TEXTUAL_HTML = /^\s*<(?:[A-Za-z][A-Za-z0-9:-]*(?:\s|>|\/)|!--)/u;
-const GIVEN_WHEN_THEN = /^\s*(?:(?:[-*+] |\d+[.)] ))?(?:(?:Given|When|Then|And|But)\b|(?:假如|当|那么|并且|但是)(?=\s|[:：]))/iu;
-const LIST_ITEM = /^\s*(?:[-*+] |\d+[.)] )\S/u;
-const STRUCTURED_CONFIG = /^\s*(?:(?:["']?[A-Za-z_][\w.-]*["']?)\s*[:=]\s*\S|--[a-z0-9][a-z0-9-]*(?:[ =]\S+)?|[A-Z][A-Z0-9_]*\s*=\s*\S)/u;
-export function sourceAuthorityDomain(item, designOwned) {
-    if (designOwned)
-        return "design";
-    if (item.kind === "acceptance")
-        return "acceptance";
-    if (item.kind === "external_confirmation")
-        return "external";
-    if (["technical_obligation", "forbidden_shortcut", "risk_fact"].includes(item.kind))
-        return "technical";
-    return "product";
-}
-export function materialSourceFragmentRef(fragment) {
-    return `${fragment.input_key}#fragment:${fragment.ordinal}:${fragment.text_sha256.slice(0, 16)}`;
-}
-export function deriveMaterialSourceFragments(item, designOwned = false) {
-    return scanMaterialTextInput({
-        input_key: item.key,
-        input_kind: "source_item",
-        source_ref: item.source_path,
-        sha256: item.text_sha256,
-        authority_source_item_refs: [item.key],
-        authority_domain: sourceAuthorityDomain(item, designOwned),
-        normalized_text: item.normalized_text,
-    }).fragments;
-}
-export function scanMaterialTextInput(input) {
-    const lines = input.normalized_text.replace(/\r\n?/gu, "\n").split("\n");
-    const raw = [];
-    const excludedSeparatorLines = [];
-    let index = 0;
-    while (index < lines.length) {
-        if (!lines[index].trim()) {
-            index += 1;
-            continue;
-        }
-        if (isSeparator(lines[index])) {
-            excludedSeparatorLines.push(index + 1);
-            index += 1;
-            continue;
-        }
-        const fence = FENCE_START.exec(lines[index]);
-        if (fence) {
-            const start = index;
-            const marker = fence[1][0];
-            const width = fence[1].length;
-            index += 1;
-            while (index < lines.length &&
-                !new RegExp(`^\\s*${escapeRegex(marker)}{${width},}\\s*$`, "u").test(lines[index]))
-                index += 1;
-            const end = Math.min(index, lines.length - 1);
-            raw.push({
-                kind: "fenced_code",
-                start,
-                end,
-                text: lines.slice(start, end + 1).join("\n"),
-            });
-            index = index < lines.length ? index + 1 : lines.length;
-            continue;
-        }
-        if (HEADING.test(lines[index])) {
-            raw.push(singleLine("heading", index, lines[index]));
-            index += 1;
-            continue;
-        }
-        if (BLOCKQUOTE.test(lines[index])) {
-            const start = index;
-            while (index < lines.length && BLOCKQUOTE.test(lines[index]))
-                index += 1;
-            raw.push({
-                kind: "blockquote",
-                start,
-                end: index - 1,
-                text: lines.slice(start, index).join("\n"),
-            });
-            continue;
-        }
-        if (TEXTUAL_HTML.test(lines[index])) {
-            const start = index;
-            index += 1;
-            while (index < lines.length &&
-                lines[index].trim() &&
-                !isSpecialLine(lines[index]))
-                index += 1;
-            raw.push({
-                kind: "textual_html",
-                start,
-                end: index - 1,
-                text: lines.slice(start, index).join("\n"),
-            });
-            continue;
-        }
-        if (TABLE_ROW.test(lines[index])) {
-            raw.push(singleLine("table_row", index, lines[index]));
-            index += 1;
-            continue;
-        }
-        if (GIVEN_WHEN_THEN.test(lines[index])) {
-            raw.push(singleLine("given_when_then", index, lines[index]));
-            index += 1;
-            continue;
-        }
-        if (LIST_ITEM.test(lines[index])) {
-            const start = index;
-            index += 1;
-            while (index < lines.length &&
-                lines[index].trim() &&
-                /^\s{2,}\S/u.test(lines[index]) &&
-                !isSpecialLine(lines[index]))
-                index += 1;
-            raw.push({
-                kind: "list_item",
-                start,
-                end: index - 1,
-                text: lines.slice(start, index).join("\n"),
-            });
-            continue;
-        }
-        if (STRUCTURED_CONFIG.test(lines[index])) {
-            raw.push(singleLine("structured_config_line", index, lines[index]));
-            index += 1;
-            continue;
-        }
-        const start = index;
-        index += 1;
-        while (index < lines.length &&
-            lines[index].trim() &&
-            !isSpecialLine(lines[index]))
-            index += 1;
-        raw.push({
-            kind: "paragraph",
-            start,
-            end: index - 1,
-            text: lines.slice(start, index).join("\n"),
-        });
-    }
-    const fragments = raw.map((entry, ordinalIndex) => {
-        const normalizedText = entry.text.trim();
-        const textSha256 = sha256Hex(normalizedText);
-        const base = {
-            input_key: input.input_key,
-            source_item_ref: input.authority_source_item_refs[0],
-            authority_source_item_refs: [...input.authority_source_item_refs],
-            source_path: input.source_ref,
-            authority_domain: input.authority_domain,
-            kind: entry.kind,
-            ordinal: ordinalIndex + 1,
-            start_line: entry.start + 1,
-            end_line: entry.end + 1,
-            normalized_text: normalizedText,
-            text_sha256: textSha256,
-        };
-        return { ...base, key: materialSourceFragmentRef(base) };
-    });
-    const materialNonblankLines = lines.flatMap((line, lineIndex) => line.trim() ? [lineIndex + 1] : []);
-    const coveredLines = fragments.flatMap((fragment) => {
-        const result = [];
-        for (let line = fragment.start_line; line <= fragment.end_line; line += 1)
-            if (lines[line - 1].trim())
-                result.push(line);
-        return result;
-    });
-    assertExactCoverage(input.input_key, materialNonblankLines, coveredLines, excludedSeparatorLines);
-    return {
-        fragments,
-        coverage: {
-            material_nonblank_lines: materialNonblankLines,
-            covered_lines: coveredLines,
-            excluded_separator_lines: excludedSeparatorLines,
-        },
-    };
-}
-function singleLine(kind, index, text) {
-    return { kind, start: index, end: index, text };
-}
-function isSeparator(line) {
-    return TABLE_SEPARATOR.test(line) || MARKDOWN_SEPARATOR.test(line);
-}
-function isSpecialLine(line) {
-    return (FENCE_START.test(line) ||
-        isSeparator(line) ||
-        HEADING.test(line) ||
-        BLOCKQUOTE.test(line) ||
-        TEXTUAL_HTML.test(line) ||
-        TABLE_ROW.test(line) ||
-        GIVEN_WHEN_THEN.test(line) ||
-        LIST_ITEM.test(line) ||
-        STRUCTURED_CONFIG.test(line));
-}
-function assertExactCoverage(inputKey, material, covered, excluded) {
-    const seen = new Set();
-    for (const line of [...covered, ...excluded]) {
-        if (seen.has(line))
-            throw new Error(`material_fragment_coverage_overlap:${inputKey}:${line}`);
-        seen.add(line);
-    }
-    if (material.length !== seen.size ||
-        material.some((line) => !seen.has(line)) ||
-        [...seen].some((line) => !material.includes(line)))
-        throw new Error(`material_fragment_coverage_mismatch:${inputKey}:${material.join(",")}:${[
-            ...seen,
-        ]
-            .sort((left, right) => left - right)
-            .join(",")}`);
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}

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

@@ -1,2 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
-export declare function compileSourceInventory(repository: string, sourcePaths: string[]): Promise<CompiledSourceItemV2[]>;