project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,202 @@
+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;
+}

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

@@ -0,0 +1,101 @@
+import type { CatalogDiagnostic } from "../context-catalog/catalog-types.js";
+import type { ContextRole } from "../context-catalog/catalog-portable-contract.js";
+import type { DefaultContextSelectionReason } from "../context-catalog/catalog-default-footprint.js";
+import type { ContextRouteBudgetName } from "./context-route-budget.js";
+export type ContextRouteTermSource = "explicit" | "quoted_phrase" | "code_identifier" | "path_fragment" | "manifest_trigger" | "stable_name";
+export interface ContextRouteTerm {
+    value: string;
+    normalized: string;
+    source: ContextRouteTermSource;
+    order: number;
+}
+export type ContextRouteGroup = "default_registered" | "on_demand_registered" | "legacy_registered" | "unregistered" | "path_candidates" | "trigger_candidates" | "literal_candidates" | "manual_includes";
+export interface ContextRouteMatch {
+    term: string;
+    term_source: ContextRouteTermSource;
+    line: number;
+    column: number;
+}
+export interface ContextRouteReason {
+    kind: "default" | "path" | "trigger" | "literal" | "manual_include";
+    input: string;
+    detail: string;
+}
+export interface ContextRouteCandidate {
+    path: string;
+    registration: "registered" | "unregistered";
+    role: ContextRole | null;
+    read_policy: string | null;
+    groups: ContextRouteGroup[];
+    reasons: ContextRouteReason[];
+    matched_terms: string[];
+    matched_paths: string[];
+    matches: ContextRouteMatch[];
+    bytes: number;
+    cumulative_bytes: number;
+}
+export interface ContextRouteDefaultEntry {
+    path: string;
+    reasons: DefaultContextSelectionReason[];
+    bytes: number;
+    cumulative_bytes: number;
+}
+export interface ContextRouteAreaCandidate {
+    id: string;
+    root: string;
+    context: string;
+}
+export interface ContextRouteAmbiguity {
+    kind: "area_path";
+    input: string;
+    candidates: ContextRouteAreaCandidate[];
+    reason: string;
+}
+export interface ContextRouteUnresolved {
+    kind: "path" | "include";
+    input: string;
+    reason: string;
+}
+export interface ContextRouteBudgetExceeded {
+    budget: ContextRouteBudgetName;
+    limit: number;
+    observed: number;
+    path?: string;
+}
+export interface ContextRouteScanReport {
+    files_considered: number;
+    files_scanned: number;
+    bytes_scanned: number;
+    budget_exceeded: boolean;
+    exceeded: ContextRouteBudgetExceeded[];
+}
+export interface ContextRouteResult {
+    schema_version: 1;
+    complete: boolean;
+    catalog_valid: boolean;
+    experimental: true;
+    authority: false;
+    workflow_search_replaced: false;
+    matching: {
+        literal: true;
+        unicode_normalization: "NFC";
+        case_sensitive: boolean;
+    };
+    scan: ContextRouteScanReport;
+    output_truncated: boolean;
+    default_context: ContextRouteDefaultEntry[];
+    candidates: ContextRouteCandidate[];
+    unregistered_matches: ContextRouteCandidate[];
+    ambiguous: ContextRouteAmbiguity[];
+    unresolved: ContextRouteUnresolved[];
+    diagnostics: CatalogDiagnostic[];
+}
+export interface ContextRouteInput {
+    project_root: string;
+    task: string;
+    paths?: string[];
+    explicit_terms?: string[];
+    includes?: string[];
+    case_sensitive?: boolean;
+    max_search_results?: number;
+}

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

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

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

@@ -0,0 +1,2 @@
+import type { ContextRouteInput, ContextRouteResult } from "./context-route-types.js";
+export declare function routeContext(input: ContextRouteInput): Promise<ContextRouteResult>;