project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/context-router/context-route-paths.js

@@ -1,109 +0,0 @@
-import { lstat, realpath } from "node:fs/promises";
-import path from "node:path";
-import { CLI_EXIT_CODES, CliCommandError } from "../cli-exit.js";
-import { compareUtf8Paths, isPathWithin, normalizeContextPath, resolveProjectPath, } from "../context-catalog/catalog-paths.js";
-import { compareRouteAmbiguities, compareRouteUnresolved, } from "./context-route-order.js";
-export function matchContextAreas(catalog, inputs) {
-    const matches = [];
-    const ambiguous = [];
-    const unresolved = [];
-    for (const normalized of normalizeRepositoryInputs(inputs, "--path")) {
-        const candidates = catalog.areas
-            .map((area) => ({
-            id: area.id.normalize("NFC"),
-            root: normalizeAreaRoot(area.root),
-            context: normalizeContextPath(area.context),
-        }))
-            .filter((area) => areaContains(area.root, normalized));
-        if (candidates.length === 0) {
-            unresolved.push({
-                kind: "path",
-                input: normalized,
-                reason: "no Area root contains the repository-relative path",
-            });
-            continue;
-        }
-        const maximum = Math.max(...candidates.map(areaScore));
-        const deepest = candidates
-            .filter((area) => areaScore(area) === maximum)
-            .sort((left, right) => compareUtf8Paths(`${left.root}\0${left.id}\0${left.context}`, `${right.root}\0${right.id}\0${right.context}`));
-        if (deepest.length > 1) {
-            ambiguous.push({
-                kind: "area_path",
-                input: normalized,
-                candidates: deepest,
-                reason: "multiple Area roots tie at the deepest matching root",
-            });
-            continue;
-        }
-        matches.push({
-            input: normalized,
-            normalized_path: normalized,
-            area: deepest[0],
-        });
-    }
-    return {
-        matches: matches.sort(comparePathMatches),
-        ambiguous: ambiguous.sort(compareRouteAmbiguities),
-        unresolved: unresolved.sort(compareRouteUnresolved),
-    };
-}
-export async function resolveManualIncludes(catalog, inputs) {
-    const files = new Map(catalog.context_files.map((file) => [file.path, file]));
-    const contextRoot = resolveProjectPath(catalog.project_root, "project_context");
-    const realContextRoot = await realpath(contextRoot);
-    const result = new Map();
-    for (const normalized of normalizeRepositoryInputs(inputs, "--include")) {
-        if (!normalized.startsWith("project_context/") ||
-            !normalized.endsWith(".md"))
-            throw new CliCommandError(CLI_EXIT_CODES.io, `route include must name an existing Markdown file under project_context/: ${normalized}`);
-        const file = files.get(normalized);
-        if (!file)
-            throw new CliCommandError(CLI_EXIT_CODES.io, `route include is missing or is not an eligible Context file: ${normalized}`);
-        const metadata = await lstat(file.absolute_path);
-        if (!metadata.isFile() || metadata.isSymbolicLink())
-            throw new CliCommandError(CLI_EXIT_CODES.io, `route include must be a regular no-follow file: ${normalized}`);
-        const identity = await realpath(file.absolute_path);
-        if (!isPathWithin(realContextRoot, identity))
-            throw new CliCommandError(CLI_EXIT_CODES.io, `route include resolves outside project_context/: ${normalized}`);
-        result.set(normalized, file);
-    }
-    return [...result.values()].sort((left, right) => compareUtf8Paths(left.path, right.path));
-}
-export function normalizeRepositoryInput(value, flag) {
-    const normalized = normalizeContextPath(value.trim());
-    if (!normalized)
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route ${flag} requires a non-empty repository-relative path`);
-    if (path.posix.isAbsolute(normalized) ||
-        path.win32.isAbsolute(normalized) ||
-        normalized.split("/").includes("..") ||
-        /^[A-Za-z]:/u.test(normalized))
-        throw new CliCommandError(CLI_EXIT_CODES.io, `route ${flag} path must stay repository-relative: ${value}`);
-    return normalized;
-}
-export function normalizeRepositoryInputs(values, flag) {
-    return [
-        ...new Set(values.map((value) => normalizeRepositoryInput(value, flag))),
-    ].sort(compareUtf8Paths);
-}
-function normalizeAreaRoot(value) {
-    const normalized = normalizeContextPath(value.trim());
-    return normalized === "" || normalized === "."
-        ? "."
-        : normalized.replace(/\/$/u, "");
-}
-function comparePathMatches(left, right) {
-    return (compareUtf8Paths(left.normalized_path, right.normalized_path) ||
-        compareUtf8Paths(left.area.root, right.area.root) ||
-        compareUtf8Paths(left.area.id, right.area.id) ||
-        compareUtf8Paths(left.area.context, right.area.context));
-}
-function areaContains(root, candidate) {
-    return root === "." || candidate === root || candidate.startsWith(`${root}/`);
-}
-function areaScore(area) {
-    if (area.root === ".")
-        return 0;
-    const depth = area.root.split("/").length;
-    return depth * 1_000_000 + Buffer.byteLength(area.root, "utf8");
-}

package/dist/lib/context-router/context-route-render.d.ts

@@ -1,2 +0,0 @@
-import type { ContextRouteResult } from "./context-route-types.js";
-export declare function renderContextRouteText(result: ContextRouteResult, explain: boolean): string;

package/dist/lib/context-router/context-route-render.js

@@ -1,32 +0,0 @@
-export function renderContextRouteText(result, explain) {
-    const lines = [
-        "Experimental Context route (diagnostic only)",
-        `complete=${result.complete} catalog_valid=${result.catalog_valid} output_truncated=${result.output_truncated}`,
-        `scan files=${result.scan.files_scanned}/${result.scan.files_considered} bytes=${result.scan.bytes_scanned}`,
-        `default Context: ${result.default_context.length} file(s)`,
-    ];
-    if (result.scan.exceeded.length > 0) {
-        for (const item of result.scan.exceeded)
-            lines.push(`budget exceeded: ${item.budget} observed=${item.observed} limit=${item.limit}${item.path ? ` path=${item.path}` : ""}`);
-    }
-    for (const candidate of [
-        ...result.candidates,
-        ...result.unregistered_matches,
-    ]) {
-        lines.push(`${candidate.registration === "unregistered" ? "unregistered" : "candidate"}: ${candidate.path} (${candidate.bytes} bytes; ${candidate.groups.join(",")})`);
-        if (!explain)
-            continue;
-        for (const reason of candidate.reasons)
-            lines.push(`  ${reason.kind}: ${reason.input} — ${reason.detail}`);
-        for (const match of candidate.matches)
-            lines.push(`  match ${match.line}:${match.column} ${match.term_source}=${JSON.stringify(match.term)}`);
-    }
-    for (const item of result.ambiguous)
-        lines.push(`ambiguous: ${item.input} -> ${item.candidates.map((entry) => `${entry.id}:${entry.root}`).join(", ")}`);
-    for (const item of result.unresolved)
-        lines.push(`unresolved: ${item.input} — ${item.reason}`);
-    for (const diagnostic of result.diagnostics)
-        lines.push(`${diagnostic.severity}: ${diagnostic.code}: ${diagnostic.message}`);
-    lines.push("This output neither establishes Authority nor replaces the Workflow-required bounded Context search.");
-    return `${lines.join("\n")}\n`;
-}

package/dist/lib/context-router/context-route-scan.d.ts

@@ -1,18 +0,0 @@
-import type { CatalogFile } from "../context-catalog/catalog-types.js";
-import type { ContextRouteMatch, ContextRouteScanReport, ContextRouteTerm } from "./context-route-types.js";
-export interface ContextRouteFileMatches {
-    matches: ContextRouteMatch[];
-    matched_terms: string[];
-    output_truncated: boolean;
-}
-export interface ContextRouteScanResult {
-    scan: ContextRouteScanReport;
-    matches_by_path: Map<string, ContextRouteFileMatches>;
-    output_truncated: boolean;
-}
-export declare function scanContextCatalogFiles(input: {
-    files: CatalogFile[];
-    terms: ContextRouteTerm[];
-    case_sensitive: boolean;
-    max_search_results: number;
-}): Promise<ContextRouteScanResult>;

package/dist/lib/context-router/context-route-scan.js

@@ -1,156 +0,0 @@
-import { open } from "node:fs/promises";
-import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
-import { CONTEXT_ROUTE_BUDGETS } from "./context-route-budget.js";
-import { stableRouteBudgetExceeded } from "./context-route-order.js";
-import { normalizeRouteText } from "./context-route-terms.js";
-export async function scanContextCatalogFiles(input) {
-    const files = [...input.files].sort((left, right) => compareUtf8Paths(left.path, right.path));
-    const exceeded = [];
-    if (files.length > CONTEXT_ROUTE_BUDGETS.candidate_files) {
-        exceeded.push({
-            budget: "candidate_files",
-            limit: CONTEXT_ROUTE_BUDGETS.candidate_files,
-            observed: files.length,
-        });
-    }
-    const selectedFiles = files.slice(0, CONTEXT_ROUTE_BUDGETS.candidate_files);
-    const matchesByPath = new Map();
-    let bytesScanned = 0;
-    let filesScanned = 0;
-    let outputCount = 0;
-    let outputTruncated = false;
-    for (const file of selectedFiles) {
-        if (file.bytes > CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes) {
-            exceeded.push({
-                budget: "per_file_scan_bytes",
-                limit: CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes,
-                observed: file.bytes,
-                path: file.path,
-            });
-        }
-        const remaining = CONTEXT_ROUTE_BUDGETS.aggregate_scan_bytes - bytesScanned;
-        if (remaining <= 0) {
-            exceeded.push({
-                budget: "aggregate_scan_bytes",
-                limit: CONTEXT_ROUTE_BUDGETS.aggregate_scan_bytes,
-                observed: bytesScanned +
-                    Math.min(file.bytes, CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes),
-                path: file.path,
-            });
-            break;
-        }
-        const byteLimit = Math.min(file.bytes, CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes, remaining);
-        if (bytesScanned +
-            Math.min(file.bytes, CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes) >
-            CONTEXT_ROUTE_BUDGETS.aggregate_scan_bytes) {
-            exceeded.push({
-                budget: "aggregate_scan_bytes",
-                limit: CONTEXT_ROUTE_BUDGETS.aggregate_scan_bytes,
-                observed: bytesScanned +
-                    Math.min(file.bytes, CONTEXT_ROUTE_BUDGETS.per_file_scan_bytes),
-                path: file.path,
-            });
-        }
-        const content = await readPrefix(file.absolute_path, byteLimit);
-        bytesScanned += content.bytes;
-        filesScanned += 1;
-        const normalized = normalizeRouteText(content.text, input.case_sensitive);
-        const fileResult = matchFile(normalized, input.terms);
-        if (fileResult.matched_terms.length === 0)
-            continue;
-        if (fileResult.output_truncated)
-            outputTruncated = true;
-        const remainingOutput = Math.max(0, input.max_search_results - outputCount);
-        const projected = fileResult.matches.slice(0, remainingOutput);
-        if (projected.length < fileResult.matches.length || remainingOutput === 0)
-            outputTruncated = true;
-        outputCount += projected.length;
-        matchesByPath.set(file.path, {
-            matches: projected,
-            matched_terms: fileResult.matched_terms,
-            output_truncated: fileResult.output_truncated,
-        });
-    }
-    return {
-        scan: {
-            files_considered: files.length,
-            files_scanned: filesScanned,
-            bytes_scanned: bytesScanned,
-            budget_exceeded: exceeded.length > 0,
-            exceeded: stableRouteBudgetExceeded(exceeded),
-        },
-        matches_by_path: matchesByPath,
-        output_truncated: outputTruncated,
-    };
-}
-async function readPrefix(absolutePath, limit) {
-    const handle = await open(absolutePath, "r");
-    try {
-        const buffer = Buffer.alloc(limit);
-        const { bytesRead } = await handle.read(buffer, 0, limit, 0);
-        return {
-            text: buffer.subarray(0, bytesRead).toString("utf8"),
-            bytes: bytesRead,
-        };
-    }
-    finally {
-        await handle.close();
-    }
-}
-function matchFile(content, terms) {
-    const found = [];
-    const matchedTerms = [];
-    for (const term of terms) {
-        let offset = content.indexOf(term.normalized);
-        if (offset < 0)
-            continue;
-        matchedTerms.push(term.value);
-        let count = 0;
-        while (offset >= 0 &&
-            count <= CONTEXT_ROUTE_BUDGETS.per_file_output_matches) {
-            found.push({
-                term: term.value,
-                term_source: term.source,
-                line: 0,
-                column: 0,
-                offset,
-                term_order: term.order,
-            });
-            count += 1;
-            offset = content.indexOf(term.normalized, offset + Math.max(1, term.normalized.length));
-        }
-    }
-    found.sort((left, right) => left.offset - right.offset || left.term_order - right.term_order);
-    const limited = found.slice(0, CONTEXT_ROUTE_BUDGETS.per_file_output_matches);
-    const starts = lineStarts(content);
-    return {
-        matched_terms: matchedTerms,
-        matches: limited.map(({ offset, term_order: _termOrder, ...entry }) => {
-            const location = lineAndColumn(content, starts, offset);
-            return { ...entry, ...location };
-        }),
-        output_truncated: found.length > limited.length,
-    };
-}
-function lineStarts(value) {
-    const starts = [0];
-    for (let index = 0; index < value.length; index += 1)
-        if (value[index] === "\n")
-            starts.push(index + 1);
-    return starts;
-}
-function lineAndColumn(value, starts, offset) {
-    let low = 0;
-    let high = starts.length - 1;
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
-        if (starts[middle] <= offset)
-            low = middle;
-        else
-            high = middle - 1;
-    }
-    return {
-        line: low + 1,
-        column: Array.from(value.slice(starts[low], offset)).length + 1,
-    };
-}

package/dist/lib/context-router/context-route-selection.d.ts

@@ -1,16 +0,0 @@
-import type { CatalogFile, ContextCatalog } from "../context-catalog/catalog-types.js";
-import type { ContextRouteFileMatches } from "./context-route-scan.js";
-import type { ContextRouteCandidate, ContextRouteDefaultEntry } from "./context-route-types.js";
-import type { ContextRoutePathMatch } from "./context-route-paths.js";
-export declare function selectContextRouteCandidates(input: {
-    catalog: ContextCatalog;
-    default_context: ContextRouteDefaultEntry[];
-    path_matches: ContextRoutePathMatch[];
-    literal_matches: Map<string, ContextRouteFileMatches>;
-    includes: CatalogFile[];
-    task: string;
-    case_sensitive: boolean;
-}): {
-    registered: ContextRouteCandidate[];
-    unregistered: ContextRouteCandidate[];
-};

package/dist/lib/context-router/context-route-selection.js

@@ -1,72 +0,0 @@
-import { addReason, projectCandidates, } from "./context-route-candidates.js";
-import { normalizeRouteText } from "./context-route-terms.js";
-export function selectContextRouteCandidates(input) {
-    const registeredByPath = new Map(input.catalog.registered_contexts.map((entry) => [entry.path, entry]));
-    const filesByPath = new Map(input.catalog.context_files.map((entry) => [entry.path, entry]));
-    const candidates = new Map();
-    addDefaultCandidates(candidates, input.catalog, filesByPath, registeredByPath, input.default_context);
-    addPathCandidates(candidates, input.catalog, filesByPath, registeredByPath, input.path_matches);
-    addTriggerCandidates(candidates, input.catalog, filesByPath, registeredByPath, input.task, input.case_sensitive);
-    addLiteralCandidates(candidates, input.catalog, filesByPath, registeredByPath, input.literal_matches);
-    addManualCandidates(candidates, input.catalog, filesByPath, registeredByPath, input.includes);
-    const registered = [];
-    const unregistered = [];
-    for (const candidate of candidates.values())
-        (candidate.registration === "registered" ? registered : unregistered).push(candidate);
-    return {
-        registered: projectCandidates(registered),
-        unregistered: projectCandidates(unregistered),
-    };
-}
-function addDefaultCandidates(candidates, catalog, files, registered, defaults) {
-    for (const entry of defaults) {
-        if (!registered.has(entry.path))
-            continue;
-        addReason(candidates, catalog, files, registered, entry.path, {
-            kind: "default",
-            input: entry.reasons.join(","),
-            detail: "registered Context belongs to the unchanged default footprint",
-        });
-    }
-}
-function addPathCandidates(candidates, catalog, files, registered, matches) {
-    for (const match of matches)
-        addReason(candidates, catalog, files, registered, match.area.context, {
-            kind: "path",
-            input: match.input,
-            detail: `deepest Area ${match.area.id} at ${match.area.root}`,
-        }, "path_candidates", match.normalized_path);
-}
-function addTriggerCandidates(candidates, catalog, files, registered, task, caseSensitive) {
-    const normalizedTask = normalizeRouteText(task, caseSensitive);
-    for (const entry of catalog.registered_contexts)
-        for (const trigger of entry.context?.triggers ?? []) {
-            const normalizedTrigger = trigger.normalize("NFC");
-            if (!normalizedTask.includes(normalizeRouteText(normalizedTrigger, caseSensitive)))
-                continue;
-            addReason(candidates, catalog, files, registered, entry.path, {
-                kind: "trigger",
-                input: normalizedTrigger,
-                detail: "Manifest trigger occurs literally in task text",
-            }, "trigger_candidates");
-        }
-}
-function addLiteralCandidates(candidates, catalog, files, registered, matchesByPath) {
-    for (const [contextPath, matches] of matchesByPath) {
-        const candidate = addReason(candidates, catalog, files, registered, contextPath, {
-            kind: "literal",
-            input: matches.matched_terms.join(", "),
-            detail: "bounded literal search matched Context text",
-        }, "literal_candidates");
-        candidate.matches = matches.matches;
-        candidate.matched_terms = matches.matched_terms;
-    }
-}
-function addManualCandidates(candidates, catalog, files, registered, includes) {
-    for (const file of includes)
-        addReason(candidates, catalog, files, registered, file.path, {
-            kind: "manual_include",
-            input: file.path,
-            detail: "caller explicitly included this eligible Context file",
-        }, "manual_includes");
-}

package/dist/lib/context-router/context-route-terms.d.ts

@@ -1,13 +0,0 @@
-import type { ContextRouteBudgetExceeded, ContextRouteTerm } from "./context-route-types.js";
-export interface ContextRouteTermBuildResult {
-    terms: ContextRouteTerm[];
-    exceeded: ContextRouteBudgetExceeded[];
-}
-export declare function buildContextRouteTerms(input: {
-    task: string;
-    explicit_terms: string[];
-    paths: string[];
-    manifest_triggers: string[];
-    case_sensitive: boolean;
-}): ContextRouteTermBuildResult;
-export declare function normalizeRouteText(value: string, caseSensitive: boolean): string;

package/dist/lib/context-router/context-route-terms.js

@@ -1,202 +0,0 @@
-import { CONTEXT_ROUTE_BUDGETS } from "./context-route-budget.js";
-import { stableRouteBudgetExceeded } from "./context-route-order.js";
-const STOP_WORDS = new Set([
-    "a",
-    "an",
-    "and",
-    "as",
-    "at",
-    "be",
-    "by",
-    "for",
-    "from",
-    "in",
-    "is",
-    "it",
-    "of",
-    "on",
-    "or",
-    "that",
-    "the",
-    "this",
-    "to",
-    "with",
-]);
-export function buildContextRouteTerms(input) {
-    const exceeded = [];
-    const terms = [];
-    const normalizedSeen = new Set();
-    let order = 0;
-    const add = (value, source) => {
-        const trimmed = value.trim();
-        if (!trimmed)
-            return;
-        const length = codePointLength(trimmed);
-        const minimum = source === "explicit"
-            ? CONTEXT_ROUTE_BUDGETS.explicit_term_min_code_points
-            : CONTEXT_ROUTE_BUDGETS.automatic_term_min_code_points;
-        if (length < minimum)
-            return;
-        if (length > CONTEXT_ROUTE_BUDGETS.term_max_code_points) {
-            exceeded.push({
-                budget: "term_max_code_points",
-                limit: CONTEXT_ROUTE_BUDGETS.term_max_code_points,
-                observed: length,
-            });
-            return;
-        }
-        const normalized = normalizeRouteText(trimmed, input.case_sensitive);
-        if (normalizedSeen.has(normalized))
-            return;
-        normalizedSeen.add(normalized);
-        terms.push({ value: trimmed.normalize("NFC"), normalized, source, order });
-        order += 1;
-    };
-    if (input.explicit_terms.length > CONTEXT_ROUTE_BUDGETS.explicit_terms) {
-        exceeded.push({
-            budget: "explicit_terms",
-            limit: CONTEXT_ROUTE_BUDGETS.explicit_terms,
-            observed: input.explicit_terms.length,
-        });
-    }
-    for (const term of input.explicit_terms.slice(0, CONTEXT_ROUTE_BUDGETS.explicit_terms))
-        add(term, "explicit");
-    const automatic = [];
-    for (const value of quotedPhrases(input.task))
-        automatic.push({ value, source: "quoted_phrase" });
-    const lexical = lexicalTokens(input.task);
-    for (const value of lexical.filter(isCodeIdentifier))
-        automatic.push({ value, source: "code_identifier" });
-    for (const value of pathFragments([...lexical, ...input.paths]))
-        automatic.push({ value, source: "path_fragment" });
-    const normalizedTask = normalizeRouteText(input.task, input.case_sensitive);
-    for (const trigger of input.manifest_triggers) {
-        const normalizedTrigger = normalizeRouteText(trigger, input.case_sensitive);
-        if (normalizedTrigger && normalizedTask.includes(normalizedTrigger))
-            automatic.push({ value: trigger, source: "manifest_trigger" });
-    }
-    for (const value of lexical.filter(isStableName))
-        automatic.push({ value, source: "stable_name" });
-    const automaticSeen = new Set();
-    const uniqueAutomatic = automatic.filter(({ value }) => {
-        const normalized = normalizeRouteText(value.trim(), input.case_sensitive);
-        if (!normalized ||
-            automaticSeen.has(normalized) ||
-            normalizedSeen.has(normalized))
-            return false;
-        automaticSeen.add(normalized);
-        return true;
-    });
-    if (uniqueAutomatic.length > CONTEXT_ROUTE_BUDGETS.automatic_terms) {
-        exceeded.push({
-            budget: "automatic_terms",
-            limit: CONTEXT_ROUTE_BUDGETS.automatic_terms,
-            observed: uniqueAutomatic.length,
-        });
-    }
-    for (const entry of uniqueAutomatic.slice(0, CONTEXT_ROUTE_BUDGETS.automatic_terms))
-        add(entry.value, entry.source);
-    return { terms, exceeded: stableRouteBudgetExceeded(exceeded) };
-}
-export function normalizeRouteText(value, caseSensitive) {
-    const normalized = value.normalize("NFC");
-    return caseSensitive ? normalized : normalized.toLowerCase();
-}
-function quotedPhrases(value) {
-    const pairs = new Map([
-        ['"', '"'],
-        ["'", "'"],
-        ["“", "”"],
-        ["‘", "’"],
-    ]);
-    const result = [];
-    const points = Array.from(value);
-    for (let index = 0; index < points.length; index += 1) {
-        const close = pairs.get(points[index]);
-        if (!close)
-            continue;
-        const start = index + 1;
-        while (index + 1 < points.length && points[index + 1] !== close)
-            index += 1;
-        if (index + 1 >= points.length)
-            break;
-        result.push(points.slice(start, index + 1).join(""));
-        index += 1;
-    }
-    return result;
-}
-function lexicalTokens(value) {
-    const result = [];
-    let current = "";
-    const flush = () => {
-        if (current)
-            result.push(current);
-        current = "";
-    };
-    for (const point of Array.from(value)) {
-        if (isLexicalCharacter(point))
-            current += point;
-        else
-            flush();
-    }
-    flush();
-    return result;
-}
-function isLexicalCharacter(value) {
-    const code = value.codePointAt(0) ?? 0;
-    return ((code >= 48 && code <= 57) ||
-        (code >= 65 && code <= 90) ||
-        (code >= 97 && code <= 122) ||
-        value === "_" ||
-        value === "$" ||
-        value === "-" ||
-        value === "." ||
-        value === "/" ||
-        value === "\\");
-}
-function isCodeIdentifier(value) {
-    if (value.includes("/") || value.includes("\\"))
-        return false;
-    const startsCorrectly = isAsciiLetter(value[0] ?? "") || "_$".includes(value[0] ?? "");
-    if (!startsCorrectly)
-        return false;
-    return (value.includes("_") ||
-        value.includes("$") ||
-        value.includes(".") ||
-        hasCamelBoundary(value));
-}
-function isStableName(value) {
-    if (value.includes("/") || value.includes("\\") || isCodeIdentifier(value))
-        return false;
-    const normalized = value.toLowerCase();
-    return codePointLength(value) >= 3 && !STOP_WORDS.has(normalized);
-}
-function hasCamelBoundary(value) {
-    for (let index = 1; index < value.length; index += 1) {
-        const previous = value.charCodeAt(index - 1);
-        const current = value.charCodeAt(index);
-        if (previous >= 97 && previous <= 122 && current >= 65 && current <= 90)
-            return true;
-    }
-    return false;
-}
-function pathFragments(values) {
-    const result = [];
-    for (const raw of values) {
-        if (!raw.includes("/") && !raw.includes("\\"))
-            continue;
-        const normalized = raw.replaceAll("\\", "/").replace(/^\.\//u, "");
-        result.push(normalized);
-        for (const segment of normalized.split("/"))
-            if (segment)
-                result.push(segment);
-    }
-    return result;
-}
-function isAsciiLetter(value) {
-    const code = value.charCodeAt(0);
-    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
-}
-function codePointLength(value) {
-    return Array.from(value).length;
-}