project-tiny-context-harness 0.11.0 → 0.12.1

package/dist/lib/context-doctor/context-doctor.js

@@ -1,130 +0,0 @@
-import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
-import { loadContextCatalog } from "../context-catalog/catalog-load.js";
-import { CONTEXT_LEGACY_READ_POLICY_SET } from "../context-catalog/catalog-portable-contract.js";
-import { analyzeContextMarkdownCatalog } from "../context-markdown/context-markdown-analysis.js";
-import { resolveContextDoctorOptions } from "./context-doctor-types.js";
-export async function inspectContextCatalogHealth(projectRoot, options = {}) {
-    const resolved = resolveContextDoctorOptions(options);
-    const result = {
-        info: [],
-        warnings: [],
-        errors: [],
-    };
-    const catalog = await loadContextCatalog(projectRoot);
-    for (const diagnostic of catalog.diagnostics) {
-        const location = diagnostic.path
-            ? `${diagnostic.path}${diagnostic.line ? `:${diagnostic.line}` : ""}: `
-            : "";
-        result[diagnostic.severity === "error" ? "errors" : "warnings"].push(`${location}${diagnostic.message}`);
-    }
-    const registeredByPath = new Map(catalog.registered_contexts.map((entry) => [entry.path, entry]));
-    const unregisteredPaths = new Set(catalog.unregistered_context_files.map((entry) => entry.path));
-    const defaultPaths = new Set(catalog.default_footprint.keys());
-    const markdown = await analyzeContextMarkdownCatalog({
-        project_root: catalog.project_root,
-        files: catalog.context_files,
-        long_line_threshold: resolved.long_line_code_points,
-    });
-    const distribution = distributionFor(catalog.context_files, registeredByPath, defaultPaths, unregisteredPaths);
-    result.info.push(`all Context Markdown: ${catalog.context_files.length} file(s), ${sumBytes(catalog.context_files)} bytes`);
-    result.info.push(`Context distribution: default=${distribution.default.files} file(s)/${distribution.default.bytes} bytes, on-demand=${distribution.on_demand.files} file(s)/${distribution.on_demand.bytes} bytes, legacy=${distribution.legacy.files} file(s)/${distribution.legacy.bytes} bytes, unregistered=${distribution.unregistered.files} file(s)/${distribution.unregistered.bytes} bytes`);
-    const largestOnDemand = [...catalog.context_files]
-        .filter((file) => isOnDemandRegistered(file.path, registeredByPath, defaultPaths))
-        .sort((left, right) => right.bytes - left.bytes || compareUtf8Paths(left.path, right.path))[0];
-    if (largestOnDemand)
-        result.info.push(`largest on-demand Context: ${largestOnDemand.path}, ${largestOnDemand.bytes} bytes`);
-    for (const file of markdown.files) {
-        const registered = registeredByPath.get(file.path);
-        const classification = classifyFile(file.path, registered, defaultPaths, unregisteredPaths);
-        result.info.push(`Context file: ${file.path}, ${file.bytes} bytes, ${classification}, max line ${file.max_line_code_points} code point(s)`);
-        if (file.bytes > resolved.context_file_soft_budget_bytes)
-            result.warnings.push(`${file.path} is ${file.bytes} bytes, above the ${resolved.context_file_soft_budget_bytes}-byte all-Context per-file soft budget; this is advisory and necessary recoverable facts take precedence`);
-        for (const line of file.long_lines)
-            result.warnings.push(`${file.path}:${line.line} has ${line.code_points} Unicode code points, above the ${resolved.long_line_code_points}-code-point advisory threshold`);
-    }
-    for (const fanout of collectTriggerFanout(catalog.registered_contexts, catalog.context_files)) {
-        result.info.push(`Context trigger: ${JSON.stringify(fanout.trigger)}, ${fanout.paths.length} Context(s), ${fanout.cumulative_bytes} cumulative bytes, paths=${fanout.paths.join(", ")}`);
-        if (fanout.paths.length >= resolved.trigger_fanout_contexts)
-            result.warnings.push(`trigger ${JSON.stringify(fanout.trigger)} fans out to ${fanout.paths.length} Contexts (${fanout.cumulative_bytes} bytes): ${fanout.paths.join(", ")}; review whether this literal trigger remains selective`);
-    }
-    for (const reference of markdown.references) {
-        if (reference.status === "valid")
-            continue;
-        const target = reference.target_path ?? reference.destination;
-        result.warnings.push(`${reference.source_path}:${reference.line} has ${reference.status.replaceAll("_", " ")} explicit Markdown Context reference ${JSON.stringify(target)}${reference.detail ? `: ${reference.detail}` : ""}`);
-    }
-    for (const declaration of markdown.invalid_declarations)
-        result.warnings.push(`${declaration.path}:${declaration.line} has invalid ty-context declaration ${JSON.stringify(declaration.raw)}: ${declaration.reason}`);
-    for (const conflict of markdown.declaration_conflicts)
-        result.warnings.push(`${conflict.type} ${conflict.id} is declared by multiple candidate owners: ${conflict.owners.map((owner) => `${owner.path}:${owner.line}`).join(", ")}`);
-    return result;
-}
-function distributionFor(files, registered, defaults, unregistered) {
-    const result = {
-        default: { files: 0, bytes: 0 },
-        on_demand: { files: 0, bytes: 0 },
-        legacy: { files: 0, bytes: 0 },
-        unregistered: { files: 0, bytes: 0 },
-    };
-    for (const file of files) {
-        const entry = registered.get(file.path);
-        let key;
-        if (unregistered.has(file.path))
-            key = "unregistered";
-        else if (defaults.has(file.path))
-            key = "default";
-        else if (entry?.read_policy &&
-            CONTEXT_LEGACY_READ_POLICY_SET.has(entry.read_policy))
-            key = "legacy";
-        else
-            key = "on_demand";
-        result[key].files += 1;
-        result[key].bytes += file.bytes;
-    }
-    return result;
-}
-function classifyFile(contextPath, registered, defaults, unregistered) {
-    if (unregistered.has(contextPath))
-        return "unregistered";
-    const policy = registered?.read_policy;
-    const suffix = policy ? `, read_policy=${policy}` : "";
-    if (defaults.has(contextPath))
-        return `default registered${suffix}`;
-    if (policy && CONTEXT_LEGACY_READ_POLICY_SET.has(policy))
-        return `legacy registered${suffix}`;
-    return `on-demand registered${suffix}`;
-}
-function isOnDemandRegistered(contextPath, registered, defaults) {
-    const entry = registered.get(contextPath);
-    return Boolean(entry &&
-        !defaults.has(contextPath) &&
-        !(entry.read_policy && CONTEXT_LEGACY_READ_POLICY_SET.has(entry.read_policy)));
-}
-function collectTriggerFanout(contexts, files) {
-    const filesByPath = new Map(files.map((file) => [file.path, file]));
-    const groups = new Map();
-    for (const context of contexts) {
-        for (const trigger of context.context?.triggers ?? []) {
-            const normalized = trigger.normalize("NFC").toLocaleLowerCase("en-US");
-            const group = groups.get(normalized) ?? {
-                display: trigger.normalize("NFC"),
-                paths: new Set(),
-            };
-            group.paths.add(context.path);
-            groups.set(normalized, group);
-        }
-    }
-    return [...groups.values()]
-        .map((group) => {
-        const paths = [...group.paths].sort(compareUtf8Paths);
-        return {
-            trigger: group.display,
-            paths,
-            cumulative_bytes: paths.reduce((total, contextPath) => total + (filesByPath.get(contextPath)?.bytes ?? 0), 0),
-        };
-    })
-        .sort((left, right) => compareUtf8Paths(left.trigger, right.trigger));
-}
-function sumBytes(files) {
-    return files.reduce((total, file) => total + file.bytes, 0);
-}

package/dist/lib/context-graph-snapshot.d.ts

@@ -1,23 +0,0 @@
-export interface ContextGraphSnapshot {
-    mode: "referenced" | "full";
-    topology_sha256: string;
-    files: string[];
-    sha256: Record<string, string>;
-    controlling_files: string[];
-    supporting_files: string[];
-}
-export interface CapturedContextGraphSnapshot {
-    snapshot: ContextGraphSnapshot;
-    physical_files: ReadonlyMap<string, string>;
-}
-export interface CampaignContextBaseline {
-    graph_sha256: string;
-    files: Record<string, string>;
-    baseline_sha256: string;
-}
-export declare function captureContextGraphSnapshot(repositoryRoot: string, contextRefs: Iterable<string>, mode?: "referenced" | "full"): Promise<ContextGraphSnapshot>;
-export declare function captureContextGraphSnapshotWithPhysicalFiles(repositoryRoot: string, contextRefs: Iterable<string>, mode?: "referenced" | "full"): Promise<CapturedContextGraphSnapshot>;
-export declare function captureCampaignContextBaseline(repositoryRoot: string, contextRefs: Iterable<string>): Promise<CampaignContextBaseline>;
-export declare function assertCampaignContextBaselineFresh(repositoryRoot: string, expected: CampaignContextBaseline, contextRefs: Iterable<string>): Promise<void>;
-export declare function currentContextTopologySha256(repositoryRoot: string): Promise<string>;
-export declare function listContextFiles(repositoryRoot: string): Promise<string[]>;

package/dist/lib/context-graph-snapshot.js

@@ -1,199 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { contextAuthorityTopologyHash } from "./long-task-context-authority-topology.js";
-import { canonicalJson, sha256Hex } from "./strict-codec.js";
-import { compareUtf8Paths, normalizeContextPath, portableContextPathCaseKey, repositoryRelativePathSpelling, } from "./context-catalog/catalog-paths.js";
-import { parseContextManifest, } from "./context-manifest-schema.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-const CONTEXT_MANIFEST_PATH = "project_context/context.toml";
-const SUPPORTING_CONTEXT_ROLES = new Set(["implementation-index", "archive"]);
-export async function captureContextGraphSnapshot(repositoryRoot, contextRefs, mode = "referenced") {
-    return (await captureContextGraphSnapshotWithPhysicalFiles(repositoryRoot, contextRefs, mode)).snapshot;
-}
-export async function captureContextGraphSnapshotWithPhysicalFiles(repositoryRoot, contextRefs, mode = "referenced") {
-    const root = path.resolve(repositoryRoot);
-    const manifest = await readContextManifest(root);
-    const fileRecords = await listContextFileRecords(root);
-    const allFiles = fileRecords.map((file) => file.path);
-    const available = new Map(fileRecords.map((file) => [file.path, file]));
-    const selected = new Set();
-    const explicitlySelected = new Set();
-    if (mode === "full") {
-        allFiles.forEach((file) => selected.add(file));
-        for (const contextRef of contextRefs) {
-            const normalized = normalizeRepoPath(contextRef);
-            if (!available.has(normalized)) {
-                throw new Error(`context_ref_invalid:${contextRef}`);
-            }
-            explicitlySelected.add(normalized);
-        }
-    }
-    else {
-        for (const required of [
-            CONTEXT_MANIFEST_PATH,
-            "project_context/global.md",
-            "project_context/architecture.md",
-        ]) {
-            if (!available.has(required)) {
-                throw new Error(`context_snapshot_required_file_missing:${required}`);
-            }
-            selected.add(required);
-            explicitlySelected.add(required);
-        }
-        for (const contextRef of contextRefs) {
-            const normalized = normalizeRepoPath(contextRef);
-            if (!available.has(normalized)) {
-                throw new Error(`context_ref_invalid:${contextRef}`);
-            }
-            selected.add(normalized);
-            explicitlySelected.add(normalized);
-        }
-        addTransitiveChildren(manifest, selected, new Set(available.keys()));
-    }
-    const files = [...selected].sort(compareUtf8Paths);
-    const authorityTopologySha256 = contextAuthorityTopologyHash(manifest, files);
-    const hashes = Object.fromEntries(await Promise.all(files.map(async (file) => [
-        file,
-        file === CONTEXT_MANIFEST_PATH
-            ? authorityTopologySha256
-            : await hashFile(root, available.get(file).absolute_path),
-    ])));
-    const classification = classifyContextFiles(manifest, files, explicitlySelected, mode);
-    return {
-        snapshot: {
-            mode,
-            topology_sha256: authorityTopologySha256,
-            files,
-            sha256: sortRecord(hashes),
-            controlling_files: classification.controlling,
-            supporting_files: classification.supporting,
-        },
-        physical_files: new Map(files.map((file) => [file, available.get(file).absolute_path])),
-    };
-}
-export async function captureCampaignContextBaseline(repositoryRoot, contextRefs) {
-    const snapshot = await captureContextGraphSnapshot(repositoryRoot, contextRefs, "referenced");
-    const files = sortRecord(snapshot.sha256);
-    return {
-        graph_sha256: snapshot.topology_sha256,
-        files,
-        baseline_sha256: sha256Hex(canonicalJson({ graph_sha256: snapshot.topology_sha256, files })),
-    };
-}
-export async function assertCampaignContextBaselineFresh(repositoryRoot, expected, contextRefs) {
-    const current = await captureCampaignContextBaseline(repositoryRoot, contextRefs);
-    if (current.graph_sha256 !== expected.graph_sha256) {
-        throw new Error("campaign_context_changed:graph");
-    }
-    if (current.baseline_sha256 !== expected.baseline_sha256) {
-        const changed = [
-            ...new Set([
-                ...Object.keys(expected.files),
-                ...Object.keys(current.files),
-            ]),
-        ]
-            .filter((file) => expected.files[file] !== current.files[file])
-            .sort(compareUtf8Paths);
-        throw new Error(`campaign_context_changed:files:${changed.join(",") || "set"}`);
-    }
-}
-export async function currentContextTopologySha256(repositoryRoot) {
-    const root = path.resolve(repositoryRoot);
-    return contextAuthorityTopologyHash(await readContextManifest(root), await listContextFiles(root));
-}
-export async function listContextFiles(repositoryRoot) {
-    return (await listContextFileRecords(path.resolve(repositoryRoot))).map((file) => file.path);
-}
-async function listContextFileRecords(repositoryRoot) {
-    const root = path.resolve(repositoryRoot);
-    const contextRoot = path.join(root, "project_context");
-    const result = new Map();
-    const portabilityKeys = new Map();
-    async function visit(directory) {
-        const entries = await readdir(directory, { withFileTypes: true });
-        entries.sort((left, right) => compareUtf8Paths(left.name, right.name));
-        for (const entry of entries) {
-            const absolute = path.join(directory, entry.name);
-            if (entry.isSymbolicLink()) {
-                throw new Error(`protected_input_symlink_not_allowed:context_authority:${absolute.replace(/\\/gu, "/")}`);
-            }
-            if (entry.isDirectory()) {
-                await visit(absolute);
-            }
-            else if (entry.isFile()) {
-                await assertProtectedRepositoryFile(root, absolute, "context_authority");
-                const physicalPath = repositoryRelativePathSpelling(root, absolute);
-                const publicPath = normalizeContextPath(physicalPath);
-                const existing = result.get(publicPath);
-                if (existing)
-                    throw new Error(`context_authority_unicode_collision:${existing.physical_path}:${physicalPath}:${publicPath}`);
-                const portabilityKey = portableContextPathCaseKey(publicPath);
-                const caseCollision = portabilityKeys.get(portabilityKey);
-                if (caseCollision && caseCollision !== publicPath)
-                    throw new Error(`context_authority_case_collision:${caseCollision}:${publicPath}`);
-                portabilityKeys.set(portabilityKey, publicPath);
-                result.set(publicPath, {
-                    path: publicPath,
-                    physical_path: physicalPath,
-                    absolute_path: absolute,
-                });
-            }
-        }
-    }
-    await visit(contextRoot);
-    return [...result.values()].sort((left, right) => compareUtf8Paths(left.path, right.path));
-}
-async function readContextManifest(root) {
-    const manifestFile = await assertProtectedRepositoryFile(root, path.join(root, "project_context", "context.toml"), "context_manifest");
-    const parsed = parseContextManifest(await readFile(manifestFile, "utf8"));
-    if (!parsed.manifest || parsed.errors.length > 0) {
-        throw new Error(`context_manifest_invalid:${parsed.errors.join("|")}`);
-    }
-    return parsed.manifest;
-}
-function addTransitiveChildren(manifest, selected, available) {
-    const children = new Map(manifest.contexts.map((entry) => [
-        normalizeRepoPath(entry.path),
-        entry.default_children.map(normalizeRepoPath),
-    ]));
-    const queue = [...selected];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        for (const child of children.get(current) ?? []) {
-            if (!available.has(child)) {
-                throw new Error(`context_graph_child_missing:${current}:${child}`);
-            }
-            if (!selected.has(child)) {
-                selected.add(child);
-                queue.push(child);
-            }
-        }
-    }
-}
-function classifyContextFiles(manifest, files, explicitlySelected, mode) {
-    if (mode === "full")
-        return { controlling: [...files], supporting: [] };
-    const roles = new Map(manifest.contexts.map((entry) => [normalizeRepoPath(entry.path), entry.role]));
-    const controlling = [];
-    const supporting = [];
-    for (const file of files) {
-        const role = roles.get(file);
-        if (explicitlySelected.has(file) ||
-            role === undefined ||
-            !SUPPORTING_CONTEXT_ROLES.has(role))
-            controlling.push(file);
-        else
-            supporting.push(file);
-    }
-    return { controlling, supporting };
-}
-async function hashFile(root, file) {
-    const protectedFile = await assertProtectedRepositoryFile(root, file, "context_authority");
-    return sha256Hex(await readFile(protectedFile));
-}
-function normalizeRepoPath(value) {
-    return normalizeContextPath(value);
-}
-function sortRecord(value) {
-    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => compareUtf8Paths(left, right)));
-}

package/dist/lib/context-mutation/mutation-long-task-guard.d.ts

@@ -1,6 +0,0 @@
-import type { ContextMutationJournal, ContextMutationPlan } from "./mutation-types.js";
-type ContextMutationAuthorityConflictPhase = "start" | "recovery";
-export declare function assertContextMutationOutsideActiveLongTask(repository: string, affectedPaths: Iterable<string>): Promise<void>;
-export declare function withContextMutationAuthorityInterlock<T>(repository: string, affectedPaths: Iterable<string>, action: () => Promise<T>, conflictPhase?: ContextMutationAuthorityConflictPhase): Promise<T>;
-export declare function contextMutationAffectedPaths(mutation: ContextMutationPlan | ContextMutationJournal): string[];
-export {};

package/dist/lib/context-mutation/mutation-long-task-guard.js

@@ -1,57 +0,0 @@
-import { CLI_EXIT_CODES, CliCommandError } from "../cli-exit.js";
-import { repositoryRoot } from "../long-task-git.js";
-import { readActiveLongTaskBinding, withActiveAuthorityLock, } from "../long-task-state.js";
-export async function assertContextMutationOutsideActiveLongTask(repository, affectedPaths) {
-    const gitRepository = await contextMutationGitRepository(repository);
-    if (!gitRepository)
-        return;
-    await assertPathsOutsideActiveLongTask(gitRepository, affectedPaths);
-}
-export async function withContextMutationAuthorityInterlock(repository, affectedPaths, action, conflictPhase = "start") {
-    const gitRepository = await contextMutationGitRepository(repository);
-    if (!gitRepository)
-        return action();
-    return withActiveAuthorityLock(gitRepository, "context_mutation", async () => {
-        await assertPathsOutsideActiveLongTask(gitRepository, affectedPaths, conflictPhase);
-        return action();
-    });
-}
-export function contextMutationAffectedPaths(mutation) {
-    const paths = new Set(mutation.files.map((entry) => entry.path));
-    if (mutation.operation_data.kind === "register")
-        paths.add(mutation.operation_data.context_path);
-    else {
-        paths.add(mutation.operation_data.from_path);
-        paths.add(mutation.operation_data.to_path);
-    }
-    return [...paths].sort((left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8")));
-}
-async function contextMutationGitRepository(repository) {
-    return repositoryRoot(repository).catch((error) => {
-        if (/(?:not a git repository|--local can only be used inside a git repository)/iu.test(message(error)))
-            return null;
-        throw new CliCommandError(CLI_EXIT_CODES.catalog, `context mutation cannot establish Long-Task Authority state: ${message(error)}`, { cause: error });
-    });
-}
-async function assertPathsOutsideActiveLongTask(gitRepository, affectedPaths, conflictPhase = "start") {
-    const active = await readActiveLongTaskBinding(gitRepository).catch((error) => {
-        throw new CliCommandError(CLI_EXIT_CODES.catalog, `context mutation cannot establish Long-Task Authority state: ${message(error)}`, { cause: error });
-    });
-    if (!active)
-        return;
-    const bound = new Set([
-        ...active.authority_snapshot.context_snapshot.files,
-        ...Object.keys(active.authority_snapshot.source_hashes),
-    ]);
-    const conflicts = [...affectedPaths]
-        .filter((file) => bound.has(file))
-        .sort((left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8")));
-    if (conflicts.length === 0)
-        return;
-    throw new CliCommandError(CLI_EXIT_CODES.catalog, conflictPhase === "recovery"
-        ? `unfinished Context mutation conflicts with active Long-Task Authority binding for ${conflicts.join(", ")}; first end or abandon that binding through its legitimate Long-Task lifecycle, then complete or rollback the transaction, then use a fresh Compile/rebind and any required Authority Revision; Compile, Revision, and activation cannot bypass the unfinished journal`
-        : `active Long-Task Authority binds ${conflicts.join(", ")}; end or abandon that binding through its legitimate Long-Task lifecycle before starting Context mutation; after the mutation, use a fresh Compile/rebind and Authority Revision only if the lifecycle requires it`);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

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

@@ -1,15 +0,0 @@
-export declare const CONTEXT_ROUTE_SCHEMA_VERSION = 1;
-export declare const CONTEXT_ROUTE_BUDGETS: Readonly<{
-    readonly task_utf8_bytes: number;
-    readonly automatic_terms: 32;
-    readonly explicit_terms: 32;
-    readonly automatic_term_min_code_points: 2;
-    readonly explicit_term_min_code_points: 1;
-    readonly term_max_code_points: 128;
-    readonly candidate_files: 4096;
-    readonly per_file_scan_bytes: number;
-    readonly aggregate_scan_bytes: number;
-    readonly output_matches: 200;
-    readonly per_file_output_matches: 20;
-}>;
-export type ContextRouteBudgetName = keyof typeof CONTEXT_ROUTE_BUDGETS;

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

@@ -1,14 +0,0 @@
-export const CONTEXT_ROUTE_SCHEMA_VERSION = 1;
-export const CONTEXT_ROUTE_BUDGETS = Object.freeze({
-    task_utf8_bytes: 8 * 1024,
-    automatic_terms: 32,
-    explicit_terms: 32,
-    automatic_term_min_code_points: 2,
-    explicit_term_min_code_points: 1,
-    term_max_code_points: 128,
-    candidate_files: 4096,
-    per_file_scan_bytes: 1024 * 1024,
-    aggregate_scan_bytes: 32 * 1024 * 1024,
-    output_matches: 200,
-    per_file_output_matches: 20,
-});

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

@@ -1,15 +0,0 @@
-import type { CatalogFile, CatalogRegisteredContext, ContextCatalog } from "../context-catalog/catalog-types.js";
-import type { ContextRouteBudgetExceeded, ContextRouteCandidate, ContextRouteDefaultEntry, ContextRouteGroup, ContextRouteReason, ContextRouteResult } from "./context-route-types.js";
-export interface MutableCandidate extends Omit<ContextRouteCandidate, "cumulative_bytes"> {
-    group_set: Set<ContextRouteGroup>;
-    reason_keys: Set<string>;
-}
-export declare function addReason(candidates: Map<string, MutableCandidate>, catalog: ContextCatalog, filesByPath: Map<string, CatalogFile>, registeredByPath: Map<string, CatalogRegisteredContext>, contextPath: string, reason: ContextRouteReason, group?: ContextRouteGroup, matchedPath?: string): MutableCandidate;
-export declare function projectCandidates(values: MutableCandidate[]): ContextRouteCandidate[];
-export declare function defaultEntries(catalog: ContextCatalog): ContextRouteDefaultEntry[];
-export declare function emptyResult(input: {
-    catalog: ContextCatalog;
-    caseSensitive: boolean;
-    defaultContext: ContextRouteDefaultEntry[];
-    exceeded: ContextRouteBudgetExceeded[];
-}): ContextRouteResult;

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

@@ -1,112 +0,0 @@
-import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
-import { CONTEXT_LEGACY_READ_POLICY_SET } from "../context-catalog/catalog-portable-contract.js";
-import { CONTEXT_ROUTE_SCHEMA_VERSION } from "./context-route-budget.js";
-import { compareRouteReasons, sortRouteGroups, stableRouteBudgetExceeded, } from "./context-route-order.js";
-export function addReason(candidates, catalog, filesByPath, registeredByPath, contextPath, reason, group, matchedPath) {
-    const registered = registeredByPath.get(contextPath);
-    const file = filesByPath.get(contextPath);
-    const current = candidates.get(contextPath) ??
-        createCandidate(catalog, registered, file, contextPath);
-    if (group)
-        current.group_set.add(group);
-    if (matchedPath && !current.matched_paths.includes(matchedPath))
-        current.matched_paths.push(matchedPath);
-    const reasonKey = `${reason.kind}\0${reason.input}\0${reason.detail}`;
-    if (!current.reason_keys.has(reasonKey)) {
-        current.reason_keys.add(reasonKey);
-        current.reasons.push(reason);
-    }
-    candidates.set(contextPath, current);
-    return current;
-}
-export function projectCandidates(values) {
-    const result = [...values].sort((left, right) => compareUtf8Paths(left.path, right.path));
-    let cumulative = 0;
-    return result.map(({ group_set, reason_keys: _reasonKeys, ...entry }) => {
-        cumulative += entry.bytes;
-        return {
-            ...entry,
-            groups: sortRouteGroups(group_set),
-            reasons: [...entry.reasons].sort(compareRouteReasons),
-            matched_paths: [...entry.matched_paths].sort(compareUtf8Paths),
-            cumulative_bytes: cumulative,
-        };
-    });
-}
-export function defaultEntries(catalog) {
-    const files = new Map(catalog.context_files.map((entry) => [entry.path, entry]));
-    const values = [...catalog.default_footprint.entries()].sort(([left], [right]) => compareUtf8Paths(left, right));
-    let cumulative = 0;
-    return values.map(([contextPath, reasons]) => {
-        const bytes = contextPath === catalog.manifest_path
-            ? Buffer.byteLength(catalog.manifest_content ?? "", "utf8")
-            : (files.get(contextPath)?.bytes ?? 0);
-        cumulative += bytes;
-        return {
-            path: contextPath,
-            reasons: [...reasons].sort(compareUtf8Paths),
-            bytes,
-            cumulative_bytes: cumulative,
-        };
-    });
-}
-export function emptyResult(input) {
-    return {
-        schema_version: CONTEXT_ROUTE_SCHEMA_VERSION,
-        complete: false,
-        catalog_valid: false,
-        experimental: true,
-        authority: false,
-        workflow_search_replaced: false,
-        matching: {
-            literal: true,
-            unicode_normalization: "NFC",
-            case_sensitive: input.caseSensitive,
-        },
-        scan: {
-            files_considered: input.catalog.context_files.length,
-            files_scanned: 0,
-            bytes_scanned: 0,
-            budget_exceeded: input.exceeded.length > 0,
-            exceeded: stableRouteBudgetExceeded(input.exceeded),
-        },
-        output_truncated: false,
-        default_context: input.defaultContext,
-        candidates: [],
-        unregistered_matches: [],
-        ambiguous: [],
-        unresolved: [],
-        diagnostics: input.catalog.diagnostics,
-    };
-}
-function createCandidate(catalog, registered, file, contextPath) {
-    const groups = classificationGroups(catalog, registered, contextPath);
-    const unregistered = catalog.unregistered_context_files.some((entry) => entry.path === contextPath);
-    return {
-        path: contextPath,
-        registration: unregistered ? "unregistered" : "registered",
-        role: registered?.role ?? null,
-        read_policy: registered?.read_policy ?? null,
-        groups,
-        group_set: new Set(groups),
-        reasons: [],
-        reason_keys: new Set(),
-        matched_terms: [],
-        matched_paths: [],
-        matches: [],
-        bytes: file?.bytes ?? 0,
-    };
-}
-function classificationGroups(catalog, registered, contextPath) {
-    if (catalog.unregistered_context_files.some((entry) => entry.path === contextPath))
-        return ["unregistered"];
-    const groups = [];
-    if (catalog.default_footprint.has(contextPath))
-        groups.push("default_registered");
-    if (registered?.read_policy &&
-        CONTEXT_LEGACY_READ_POLICY_SET.has(registered.read_policy))
-        groups.push("legacy_registered");
-    else if (!catalog.default_footprint.has(contextPath))
-        groups.push("on_demand_registered");
-    return groups;
-}

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

@@ -1,6 +0,0 @@
-import type { ContextRouteAmbiguity, ContextRouteBudgetExceeded, ContextRouteGroup, ContextRouteReason, ContextRouteUnresolved } from "./context-route-types.js";
-export declare function compareRouteReasons(left: ContextRouteReason, right: ContextRouteReason): number;
-export declare function sortRouteGroups(groups: Iterable<ContextRouteGroup>): ContextRouteGroup[];
-export declare function stableRouteBudgetExceeded(values: readonly ContextRouteBudgetExceeded[]): ContextRouteBudgetExceeded[];
-export declare function compareRouteAmbiguities(left: ContextRouteAmbiguity, right: ContextRouteAmbiguity): number;
-export declare function compareRouteUnresolved(left: ContextRouteUnresolved, right: ContextRouteUnresolved): number;

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

@@ -1,53 +0,0 @@
-import { compareUtf8Paths, normalizeContextPath, } from "../context-catalog/catalog-paths.js";
-export function compareRouteReasons(left, right) {
-    return (compareUtf8Paths(left.kind, right.kind) ||
-        compareUtf8Paths(left.input, right.input) ||
-        compareUtf8Paths(left.detail, right.detail));
-}
-export function sortRouteGroups(groups) {
-    return [...groups].sort(compareUtf8Paths);
-}
-export function stableRouteBudgetExceeded(values) {
-    const merged = new Map();
-    for (const entry of values) {
-        const normalized = {
-            ...entry,
-            ...(entry.path ? { path: normalizeContextPath(entry.path) } : {}),
-        };
-        const key = `${normalized.budget}\0${normalized.path ?? ""}`;
-        const current = merged.get(key);
-        merged.set(key, current
-            ? {
-                ...normalized,
-                limit: Math.min(current.limit, normalized.limit),
-                observed: Math.max(current.observed, normalized.observed),
-            }
-            : normalized);
-    }
-    return [...merged.values()].sort((left, right) => compareUtf8Paths(left.budget, right.budget) ||
-        compareUtf8Paths(left.path ?? "", right.path ?? "") ||
-        left.limit - right.limit ||
-        left.observed - right.observed);
-}
-export function compareRouteAmbiguities(left, right) {
-    return (compareUtf8Paths(left.kind, right.kind) ||
-        compareUtf8Paths(left.input, right.input) ||
-        compareAreaCandidateLists(left.candidates, right.candidates) ||
-        compareUtf8Paths(left.reason, right.reason));
-}
-export function compareRouteUnresolved(left, right) {
-    return (compareUtf8Paths(left.kind, right.kind) ||
-        compareUtf8Paths(left.input, right.input) ||
-        compareUtf8Paths(left.reason, right.reason));
-}
-function compareAreaCandidateLists(left, right) {
-    const length = Math.min(left.length, right.length);
-    for (let index = 0; index < length; index += 1) {
-        const comparison = compareUtf8Paths(left[index].root, right[index].root) ||
-            compareUtf8Paths(left[index].id, right[index].id) ||
-            compareUtf8Paths(left[index].context, right[index].context);
-        if (comparison !== 0)
-            return comparison;
-    }
-    return left.length - right.length;
-}

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

@@ -1,16 +0,0 @@
-import type { CatalogFile, ContextCatalog } from "../context-catalog/catalog-types.js";
-import type { ContextRouteAmbiguity, ContextRouteAreaCandidate, ContextRouteUnresolved } from "./context-route-types.js";
-export interface ContextRoutePathMatch {
-    input: string;
-    normalized_path: string;
-    area: ContextRouteAreaCandidate;
-}
-export interface ContextRoutePathResult {
-    matches: ContextRoutePathMatch[];
-    ambiguous: ContextRouteAmbiguity[];
-    unresolved: ContextRouteUnresolved[];
-}
-export declare function matchContextAreas(catalog: ContextCatalog, inputs: string[]): ContextRoutePathResult;
-export declare function resolveManualIncludes(catalog: ContextCatalog, inputs: string[]): Promise<CatalogFile[]>;
-export declare function normalizeRepositoryInput(value: string, flag: string): string;
-export declare function normalizeRepositoryInputs(values: readonly string[], flag: string): string[];