project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-semantic-fact-value-closure.js

@@ -1,110 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveSemanticFactPointer, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { canonicalValueJson, parseStrictYaml, sha256Hex, } from "./strict-codec.js";
-export async function validateSemanticFactLocatedValues(repository, manifest, sourceItems) {
-    const values = collectLocatedValues(manifest);
-    const inputs = new Map(manifest.inputs.map((item) => [item.key, item]));
-    const sourceItemByKey = new Map(sourceItems.map((item) => [item.key, item]));
-    const resourceCache = new Map();
-    for (const entry of values) {
-        const located = entry.value;
-        if (located.representation === "digest_only")
-            continue;
-        const resolved = await resolveLocatedValue(repository, manifest, entry.label, located, inputs, sourceItemByKey, resourceCache);
-        if (resolved.external)
-            continue;
-        if (located.representation === "inline" &&
-            canonicalValueJson(resolved.value) !== canonicalValueJson(located.value))
-            semanticFactClosureInvalid("inline_value_locator_mismatch", entry.label);
-        const digest = sha256Hex(canonicalValueJson(resolved.value));
-        if (digest !== located.sha256)
-            semanticFactClosureInvalid("located_value_digest_mismatch", `${entry.label}:${located.sha256}:${digest}`);
-    }
-}
-function collectLocatedValues(manifest) {
-    return [
-        ...manifest.populations.map((item) => ({
-            label: `population:${item.key}:universe`,
-            value: item.universe,
-        })),
-        ...manifest.facts.map((item) => ({
-            label: `fact:${item.key}:expected`,
-            value: item.expected,
-        })),
-        ...manifest.proof_obligations.flatMap((item) => [
-            {
-                label: `proof:${item.key}:parameters`,
-                value: item.comparison.parameters,
-            },
-            ...(item.comparison.tolerance
-                ? [
-                    {
-                        label: `proof:${item.key}:tolerance`,
-                        value: item.comparison.tolerance,
-                    },
-                ]
-                : []),
-            ...(item.comparison.mask
-                ? [
-                    {
-                        label: `proof:${item.key}:mask`,
-                        value: item.comparison.mask,
-                    },
-                ]
-                : []),
-        ]),
-        ...manifest.environments.map((item) => ({
-            label: `environment:${item.key}`,
-            value: item.definition,
-        })),
-    ];
-}
-async function resolveLocatedValue(repository, manifest, label, located, inputs, sourceItemByKey, resourceCache) {
-    if (located.locator.kind === "manifest_pointer")
-        return {
-            external: false,
-            value: resolveSemanticFactPointer(manifest, located.locator.value, label),
-        };
-    const input = inputs.get(located.locator.material_ref);
-    if (!input)
-        semanticFactClosureInvalid("located_value_input_unknown", `${label}:${located.locator.material_ref}`);
-    if (located.locator.kind === "source_item") {
-        if (input.kind !== "source_item")
-            semanticFactClosureInvalid("located_value_source_item_kind_mismatch", label);
-        const sourceItem = sourceItemByKey.get(input.source_ref);
-        if (!sourceItem)
-            semanticFactClosureInvalid("located_value_source_item_unknown", label);
-        return { external: false, value: sourceItem.normalized_text };
-    }
-    const resource = await loadLocatedResource(repository, input.source_ref, label, located.locator.kind, resourceCache);
-    if (located.locator.kind === "whole_resource")
-        return { external: false, value: resource.raw };
-    if (located.locator.kind === "json_pointer" ||
-        located.locator.kind === "yaml_pointer" ||
-        located.locator.kind === "schema_pointer")
-        return {
-            external: false,
-            value: resolveSemanticFactPointer(resource.parsed, located.locator.value, label),
-        };
-    if (manifest.inspector.trust !== "named_external_tcb" ||
-        !manifest.inspector.capabilities.includes(`resolve.${located.locator.kind}`))
-        semanticFactClosureInvalid("located_value_external_resolver_required", `${label}:${located.locator.kind}`);
-    return { external: true, value: undefined };
-}
-async function loadLocatedResource(repository, sourceRef, label, locatorKind, cache) {
-    const cached = cache.get(sourceRef);
-    if (cached)
-        return cached;
-    const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourceRef.split("/")), `semantic_fact_located_value:${label}`);
-    const raw = await readFile(file, "utf8");
-    let parsed = raw;
-    if (locatorKind === "json_pointer" || locatorKind === "schema_pointer")
-        parsed = JSON.parse(raw);
-    else if (locatorKind === "yaml_pointer")
-        parsed = parseStrictYaml(raw);
-    const resource = { raw, parsed };
-    cache.set(sourceRef, resource);
-    return resource;
-}

package/dist/lib/long-task-semantic-mutation.d.ts

@@ -1,7 +0,0 @@
-import type { CounterfactualMutationV2 } from "./long-task-delivery-types.js";
-type NarrowMutation = Extract<CounterfactualMutationV2, {
-    type: "replace_json_value" | "replace_text";
-}>;
-export declare function applyNarrowSemanticMutation(root: string, mutation: NarrowMutation): Promise<void>;
-export declare function mutateSemanticText(current: string, mutation: NarrowMutation, requireChange?: boolean): string;
-export {};

package/dist/lib/long-task-semantic-mutation.js

@@ -1,81 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { canonicalValueJson } from "./strict-codec.js";
-export async function applyNarrowSemanticMutation(root, mutation) {
-    const target = path.join(root, ...mutation.path.split("/"));
-    const current = await readFile(target, "utf8");
-    const next = mutateSemanticText(current, mutation, false);
-    await writeFile(target, next, "utf8");
-}
-export function mutateSemanticText(current, mutation, requireChange = true) {
-    if (mutation.type === "replace_text") {
-        if (requireChange && mutation.match === mutation.replacement)
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        const count = occurrences(current, mutation.match);
-        if (count !== 1)
-            throw new Error(`counterfactual_text_match_count:${count}`);
-        return current.replace(mutation.match, mutation.replacement);
-    }
-    let value;
-    try {
-        value = JSON.parse(current);
-    }
-    catch {
-        throw new Error("counterfactual_json_invalid");
-    }
-    const segments = mutation.pointer
-        .slice(1)
-        .split("/")
-        .map((segment) => segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
-    let owner = value;
-    for (const segment of segments.slice(0, -1))
-        owner = child(owner, segment, mutation.pointer);
-    const leaf = segments.at(-1);
-    if (!owner || typeof owner !== "object")
-        throw new Error(`counterfactual_json_pointer_unknown:${mutation.pointer}`);
-    if (Array.isArray(owner)) {
-        const index = arrayIndex(leaf, owner.length, mutation.pointer);
-        if (requireChange &&
-            canonicalValueJson(owner[index]) === canonicalValueJson(mutation.value))
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        owner[index] = mutation.value;
-    }
-    else {
-        const record = owner;
-        if (!Object.hasOwn(record, leaf))
-            throw new Error(`counterfactual_json_pointer_unknown:${mutation.pointer}`);
-        if (requireChange &&
-            canonicalValueJson(record[leaf]) === canonicalValueJson(mutation.value))
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        record[leaf] = mutation.value;
-    }
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function child(value, segment, pointer) {
-    if (!value || typeof value !== "object")
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    if (Array.isArray(value))
-        return value[arrayIndex(segment, value.length, pointer)];
-    if (!Object.hasOwn(value, segment))
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    return value[segment];
-}
-function arrayIndex(value, length, pointer) {
-    if (!/^(?:0|[1-9][0-9]*)$/u.test(value))
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    const index = Number(value);
-    if (!Number.isSafeInteger(index) || index >= length)
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    return index;
-}
-function occurrences(value, search) {
-    let count = 0;
-    let offset = 0;
-    while (true) {
-        const index = value.indexOf(search, offset);
-        if (index < 0)
-            return count;
-        count += 1;
-        offset = index + search.length;
-    }
-}

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

@@ -1,21 +0,0 @@
-export type Shape = Record<string, unknown>;
-export declare function object(value: unknown, label: string, required: string[], optional?: string[]): Shape;
-export declare function array(value: unknown, label: string): unknown[];
-export declare function string(value: unknown, label: string): string;
-export declare function text(value: unknown, label: string): string;
-export declare function boolean(value: unknown, label: string): boolean;
-export declare function strings(value: unknown, label: string): string[];
-export declare function repositoryFile(value: unknown, label: string): string;
-export declare function repositoryFiles(value: unknown, label: string): string[];
-export declare function repositoryPattern(value: unknown, label: string): string;
-export declare function repositoryPatterns(value: unknown, label: string): string[];
-export declare function repositoryCwd(value: unknown, label: string): string;
-export declare function repositorySourceRef(value: unknown, label: string): string;
-export declare function literal<T extends string>(value: unknown, allowed: readonly T[], label: string): T;
-export declare function key(value: unknown, label: string): string;
-export declare function semanticRef(value: unknown, label: string): string;
-export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
-export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
-export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
-export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "external_side_effect", "failure_injection", "visual_render", "design_conformance", "design_method", "design_symbolic_certificate", "semantic_fact", "target_runtime", "input_variation"];
-export declare function fail(label: string, message: string): never;

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

@@ -1,116 +0,0 @@
-import { normalizeRepositoryCwd, normalizeRepositoryFile, parseRepositoryPattern, } from "./long-task-paths.js";
-export function object(value, label, required, optional = []) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        fail(label, "must be an object");
-    const row = value;
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(row).filter((name) => !allowed.has(name));
-    if (unknown.length)
-        fail(label, `unknown keys: ${unknown.join(",")}`);
-    const missing = required.filter((name) => !(name in row));
-    if (missing.length)
-        fail(label, `missing keys: ${missing.join(",")}`);
-    return row;
-}
-export function array(value, label) {
-    if (!Array.isArray(value))
-        fail(label, "must be an array");
-    return value;
-}
-export function string(value, label) {
-    if (typeof value !== "string" || !value.trim())
-        fail(label, "must be a non-empty string");
-    return value;
-}
-export function text(value, label) {
-    if (typeof value !== "string")
-        fail(label, "must be a string");
-    return value;
-}
-export function boolean(value, label) {
-    if (typeof value !== "boolean")
-        fail(label, "must be a boolean");
-    return value;
-}
-export function strings(value, label) {
-    return array(value, label).map((item, index) => string(item, `${label}[${index}]`));
-}
-export function repositoryFile(value, label) {
-    return normalizeRepositoryFile(string(value, label), label);
-}
-export function repositoryFiles(value, label) {
-    return array(value, label).map((item, index) => repositoryFile(item, `${label}[${index}]`));
-}
-export function repositoryPattern(value, label) {
-    return parseRepositoryPattern(string(value, label), label).normalized;
-}
-export function repositoryPatterns(value, label) {
-    return array(value, label).map((item, index) => repositoryPattern(item, `${label}[${index}]`));
-}
-export function repositoryCwd(value, label) {
-    return normalizeRepositoryCwd(string(value, label), label);
-}
-export function repositorySourceRef(value, label) {
-    const sourceRef = string(value, label);
-    const [file, anchor, ...extra] = sourceRef.split("#");
-    if (!file || extra.length || (anchor !== undefined && !anchor))
-        fail(label, "source_claim_ref_invalid");
-    const normalized = normalizeRepositoryFile(file, `${label}.file`);
-    return anchor === undefined ? normalized : `${normalized}#${anchor}`;
-}
-export function literal(value, allowed, label) {
-    if (typeof value !== "string" || !allowed.includes(value))
-        fail(label, `must be one of ${allowed.join(",")}`);
-    return value;
-}
-export function key(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))
-        fail(label, "must match ^[a-z0-9][a-z0-9-]*$");
-    return result;
-}
-export function semanticRef(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))
-        fail(label, "must be a stable lowercase semantic reference");
-    return result;
-}
-export function nullable(value, parser) {
-    return value === null ? null : parser(value);
-}
-export const PROOF_SURFACES = [
-    "ui_browser",
-    "runtime_behavior",
-    "api_contract",
-    "data_state",
-    "security_boundary",
-    "population_coverage",
-    "implementation_structure",
-];
-export const JOURNEY_ROLES = [
-    "success",
-    "degradation",
-    "recovery",
-    "stage_gate",
-    "conformance",
-];
-export const EVIDENCE_CAPABILITIES = [
-    "presence",
-    "interaction_trace",
-    "state_delta",
-    "cross_surface_consistency",
-    "durable_readback",
-    "boundary_invocation",
-    "external_side_effect",
-    "failure_injection",
-    "visual_render",
-    "design_conformance",
-    "design_method",
-    "design_symbolic_certificate",
-    "semantic_fact",
-    "target_runtime",
-    "input_variation",
-];
-export function fail(label, message) {
-    throw new Error(`delivery_contract_invalid:${label}:${message}`);
-}

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

@@ -1,15 +0,0 @@
-import type { RiskFactName } from "./long-task-risk-types.js";
-export type SourceItemKind = "outcome_result" | "requirement" | "control" | "acceptance" | "technical_obligation" | "non_completing" | "non_goal" | "forbidden_shortcut" | "risk_fact" | "external_confirmation" | "decision";
-export type SourceItemAspect = "architecture";
-export interface CompiledSourceItemV2 {
-    key: string;
-    kind: SourceItemKind;
-    aspect?: SourceItemAspect;
-    source_path: string;
-    normalized_text: string;
-    text_sha256: string;
-    risk_semantics?: {
-        fact: RiskFactName;
-        affected_outcome: string;
-    };
-}

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

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

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

@@ -1,5 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { compileProductClaimCoverage } from "./long-task-claims.js";
-export declare function validateSourceClaimMappings(contract: DeliveryContractV2, compiledClaims: ReturnType<typeof compileProductClaimCoverage>, report?: ValidationReporter): void;
-type ValidationReporter = (message: string) => void;
-export {};

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

@@ -1,99 +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 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);
-    }
-}
-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-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-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[]>;

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

@@ -1,21 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { parseSourceItems } from "./long-task-source-item-parser.js";
-export async function compileSourceInventory(repository, sourcePaths) {
-    const items = [];
-    const seen = new Set();
-    for (const [index, relative] of sourcePaths.entries()) {
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), `source[${index}]`);
-        const parsed = parseSourceItems(relative, await readFile(file, "utf8"));
-        if (!parsed.length)
-            throw new Error(`source_file_material_item_required:${relative}`);
-        for (const item of parsed) {
-            if (seen.has(item.key))
-                throw new Error(`source_item_key_duplicate:${item.key}`);
-            seen.add(item.key);
-            items.push(item);
-        }
-    }
-    return items.sort((left, right) => left.key.localeCompare(right.key));
-}

package/dist/lib/long-task-source-item-parser.d.ts

@@ -1,11 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
-import type { DesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export interface ParsedSourceDocument {
-    items: CompiledSourceItemV2[];
-    designResourceHandoff: DesignResourceHandoffInput | null;
-    semanticFactManifest: SemanticFactManifestV1 | null;
-}
-export declare function parseSourceItems(sourcePath: string, content: string): CompiledSourceItemV2[];
-export declare function parseSourceDocument(sourcePath: string, content: string): ParsedSourceDocument;
-export { normalizeSourceItemText } from "./long-task-source-markers.js";