@otto-code/brain 0.7.6 → 0.8.1

package/dist/service/host-api.js

@@ -0,0 +1,397 @@
+import { calibrationInfo, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, } from "../config/profile-edit.js";
+import { forModel, getCalibration, put } from "../config/profiles.js";
+import { deleteModelFiles, diskUsage, planDelete, totalModelBytes } from "../models/manage.js";
+import * as vram from "../vram.js";
+import { errorMessage, readJsonBody, sendError, sendJson } from "./http-util.js";
+const MAX_PATCH_BYTES = 256 * 1024;
+const DEFAULT_LOG_LINES = 200;
+function stateOf(supervisor, model) {
+    if (!supervisor.model || supervisor.model.id !== model.id)
+        return "not-loaded";
+    if (supervisor.state === "ready")
+        return "loaded";
+    if (supervisor.state === "starting")
+        return "loading";
+    return "not-loaded";
+}
+/**
+ * Join one model's scan row, GGUF metadata, saved profile, calibration, VRAM
+ * budget and benchmark score into the single shape the Models tab renders.
+ *
+ * Exported for testing: the join is the part worth pinning down, since the
+ * client would otherwise have to correlate three unrelated lists by display name.
+ */
+export function buildInventoryRow(params) {
+    const { model, store, defaults, gpu, ranking, supervisor } = params;
+    const profile = forModel(store, model, defaults);
+    const calibration = getCalibration(store, model, profile);
+    const budgetOptions = gpu
+        ? { model, profile, calibration, totalVramBytes: gpu.totalBytes }
+        : null;
+    const ranked = ranking.find((r) => r.id === model.id || r.displayName === model.displayName) ?? null;
+    return {
+        id: model.id,
+        displayName: model.displayName,
+        publisher: model.publisher ?? null,
+        quant: model.quant,
+        sizeBytes: model.sizeBytes,
+        mmprojBytes: model.mmprojBytes,
+        origin: model.origin ?? null,
+        arch: model.metadata?.arch ?? null,
+        contextLength: model.metadata?.contextLength ?? null,
+        blockCount: model.metadata?.blockCount ?? null,
+        headCountKv: model.metadata?.headCountKv ?? null,
+        hasProjector: Boolean(model.mmprojPath),
+        reasoning: Boolean(model.metadata?.reasoning ?? model.thinking),
+        mtp: Boolean(model.features?.mtp),
+        distilled: Boolean(model.features?.distilled),
+        useCases: model.useCases ?? [],
+        tier: model.tier ?? null,
+        profile,
+        calibration: calibrationInfo(store, model, profile),
+        budget: budgetOptions ? vram.budget(budgetOptions) : null,
+        maxContextThatFits: budgetOptions ? vram.maxContextThatFits(budgetOptions) : null,
+        score: ranked,
+        state: stateOf(supervisor, model),
+        warnings: profileWarnings(profile, model, store),
+    };
+}
+/** Resolve a model by id or display name, the same way the completion path does. */
+function resolveModel(catalog, needle) {
+    if (!needle)
+        return null;
+    return catalog.find((m) => m.id === needle || m.displayName === needle) ?? null;
+}
+/**
+ * Read a hypothetical profile from query parameters, so the client can show the
+ * VRAM budget updating as a field is edited without persisting a value the user
+ * may be in the middle of scrubbing past.
+ */
+function profileFromQuery(base, params, model) {
+    const patch = {};
+    const numeric = ["contextSize", "gpuLayers", "parallelSlots", "reasoningBudget"];
+    for (const key of numeric) {
+        const raw = params.get(key);
+        if (raw !== null && raw !== "")
+            patch[key] = Number(raw);
+    }
+    for (const key of ["cacheTypeK", "cacheTypeV"]) {
+        const raw = params.get(key);
+        if (raw)
+            patch[key] = raw;
+    }
+    for (const key of ["flashAttention", "vision"]) {
+        const raw = params.get(key);
+        if (raw !== null && raw !== "")
+            patch[key] = raw === "true" || raw === "1";
+    }
+    if (Object.keys(patch).length === 0)
+        return base;
+    return sanitizeProfilePatch(base, patch, model).profile;
+}
+/**
+ * Build the `/__host/*` management handler.
+ */
+export function createHostApi(deps) {
+    const capabilities = () => ({
+        profiles: true,
+        budget: true,
+        logs: true,
+        delete: true,
+        load: true,
+        resources: true,
+        inventory: true,
+        writable: deps.getAllowWrite(),
+    });
+    /** Refuse a write unless the owner opted into remote configuration. */
+    const guardWrite = (res) => {
+        if (deps.getAllowWrite())
+            return true;
+        sendError(res, 403, "remote configuration is disabled on this brain; enable it with `otto brain share --allow-config`");
+        return false;
+    };
+    const inventory = async () => {
+        const [gpu, store] = [await deps.queryGpuInfo(), deps.getProfilesStore()];
+        const defaults = deps.getProfileDefaults();
+        const ranking = deps.getRanking();
+        return deps
+            .getCatalog()
+            .map((model) => buildInventoryRow({ model, store, defaults, gpu, ranking, supervisor: deps.supervisor }));
+    };
+    const handleModelsList = (res) => {
+        void (async () => {
+            try {
+                const models = await inventory();
+                const dir = deps.getModelsDir();
+                const disk = dir ? await diskUsage(dir) : null;
+                sendJson(res, {
+                    models,
+                    disk: disk ? { ...disk, modelBytes: totalModelBytes(deps.getCatalog()) } : null,
+                });
+            }
+            catch (error) {
+                sendError(res, 500, `could not build the model inventory: ${errorMessage(error)}`);
+            }
+        })();
+    };
+    const handleProfileGet = (res, model) => {
+        const store = deps.getProfilesStore();
+        const profile = forModel(store, model, deps.getProfileDefaults());
+        sendJson(res, {
+            profile,
+            fields: profileFieldDescriptors(model),
+            warnings: profileWarnings(profile, model, store),
+            calibration: calibrationInfo(store, model, profile),
+        });
+    };
+    const handleProfileSet = (req, res, model) => {
+        readJsonBody(req, MAX_PATCH_BYTES, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            void (async () => {
+                try {
+                    const store = deps.getProfilesStore();
+                    const current = forModel(store, model, deps.getProfileDefaults());
+                    const { profile, adjustments } = sanitizeProfilePatch(current, result.body, model);
+                    deps.saveProfiles(put(store, model, profile));
+                    // Return the recomputed budget so an edit costs one round trip rather
+                    // than a write followed by a read the UI has to sequence.
+                    const gpu = await deps.queryGpuInfo();
+                    const calibration = getCalibration(store, model, profile);
+                    const options = gpu
+                        ? { model, profile, calibration, totalVramBytes: gpu.totalBytes }
+                        : null;
+                    sendJson(res, {
+                        profile,
+                        adjustments,
+                        warnings: profileWarnings(profile, model, store),
+                        calibration: calibrationInfo(store, model, profile),
+                        budget: options ? vram.budget(options) : null,
+                        maxContextThatFits: options ? vram.maxContextThatFits(options) : null,
+                        /** True when the running model is the one just edited: a restart applies it. */
+                        requiresRestart: deps.supervisor.model?.id === model.id,
+                    });
+                }
+                catch (error) {
+                    sendError(res, 400, errorMessage(error));
+                }
+            })();
+        });
+    };
+    const handleBudget = (res, model, params) => {
+        void (async () => {
+            try {
+                const store = deps.getProfilesStore();
+                const saved = forModel(store, model, deps.getProfileDefaults());
+                const profile = profileFromQuery(saved, params, model);
+                const gpu = await deps.queryGpuInfo();
+                if (!gpu) {
+                    sendJson(res, {
+                        profile,
+                        budget: null,
+                        maxContextThatFits: null,
+                        gpu: null,
+                        reason: "no NVIDIA GPU detected",
+                    });
+                    return;
+                }
+                const options = {
+                    model,
+                    profile,
+                    calibration: getCalibration(store, model, profile),
+                    totalVramBytes: gpu.totalBytes,
+                };
+                sendJson(res, {
+                    profile,
+                    budget: vram.budget(options),
+                    maxContextThatFits: vram.maxContextThatFits(options),
+                    gpu: { name: gpu.name, totalBytes: gpu.totalBytes, usedBytes: gpu.usedBytes },
+                    warnings: profileWarnings(profile, model, store),
+                });
+            }
+            catch (error) {
+                sendError(res, 400, errorMessage(error));
+            }
+        })();
+    };
+    const handleLoad = (res, model) => {
+        void (async () => {
+            const store = deps.getProfilesStore();
+            const profile = forModel(store, model, deps.getProfileDefaults());
+            // The TUI refuses this combination at the `s` key rather than letting
+            // llama-server fail to allocate the cache and time out at "starting".
+            const blocking = profileWarnings(profile, model, store).find((w) => w.blocksStart);
+            if (blocking) {
+                sendError(res, 409, blocking.message);
+                return;
+            }
+            try {
+                await deps.loadModel(model);
+                sendJson(res, {
+                    status: deps.supervisor.status(),
+                    // What actually got used: loadModel fits the profile to VRAM, so the
+                    // context here may be lower than the one saved.
+                    profile: deps.supervisor.profile,
+                });
+            }
+            catch (error) {
+                sendError(res, 409, `could not load ${model.displayName}: ${errorMessage(error)}`);
+            }
+        })();
+    };
+    const handleUnload = (res) => {
+        void (async () => {
+            try {
+                await deps.supervisor.stop();
+                sendJson(res, { status: deps.supervisor.status() });
+            }
+            catch (error) {
+                sendError(res, 500, `could not unload: ${errorMessage(error)}`);
+            }
+        })();
+    };
+    const handleDelete = (res, model) => {
+        if (deps.supervisor.model?.id === model.id && deps.supervisor.state !== "stopped") {
+            sendError(res, 409, "stop the model before deleting it");
+            return;
+        }
+        try {
+            const plan = deleteModelFiles(model);
+            const catalog = deps.rescan();
+            sendJson(res, {
+                deleted: plan.files,
+                freedBytes: plan.bytes,
+                includesProjector: plan.includesProjector,
+                remaining: catalog.length,
+            });
+        }
+        catch (error) {
+            sendError(res, 500, `could not delete ${model.displayName}: ${errorMessage(error)}`);
+        }
+    };
+    const handleLogs = (res, params) => {
+        const raw = Number(params.get("limit"));
+        const limit = Number.isFinite(raw) && raw > 0 ? Math.min(Math.round(raw), 1000) : DEFAULT_LOG_LINES;
+        const all = deps.supervisor.logLines;
+        sendJson(res, {
+            lines: all.slice(-limit),
+            total: all.length,
+            state: deps.supervisor.state,
+            command: deps.supervisor.command,
+        });
+    };
+    function handleHostApi(req, res) {
+        const raw = req.url || "";
+        if (!raw.startsWith("/__host/"))
+            return false;
+        const url = new URL(raw, "http://brain.local");
+        const route = url.pathname;
+        const params = url.searchParams;
+        const method = (req.method || "GET").toUpperCase();
+        if (route === "/__host/capabilities" && method === "GET") {
+            sendJson(res, capabilities());
+            return true;
+        }
+        if (route === "/__host/logs" && method === "GET") {
+            handleLogs(res, params);
+            return true;
+        }
+        if (route === "/__host/resources" && method === "GET") {
+            void (async () => {
+                try {
+                    sendJson(res, await deps.sampleResources());
+                }
+                catch (error) {
+                    sendError(res, 500, `could not sample resources: ${errorMessage(error)}`);
+                }
+            })();
+            return true;
+        }
+        if (route === "/__host/models" && method === "GET") {
+            handleModelsList(res);
+            return true;
+        }
+        if (route === "/__host/model/unload" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleUnload(res);
+            return true;
+        }
+        // Everything below is model-scoped and needs ?id=.
+        const modelRoutes = new Set([
+            "/__host/model",
+            "/__host/model/profile",
+            "/__host/model/budget",
+            "/__host/model/load",
+            "/__host/model/fields",
+        ]);
+        if (!modelRoutes.has(route))
+            return false;
+        const needle = params.get("id");
+        const model = resolveModel(deps.getCatalog(), needle);
+        if (!model) {
+            sendError(res, 404, needle ? `model "${needle}" was not found` : "an ?id= is required");
+            return true;
+        }
+        if (route === "/__host/model/fields" && method === "GET") {
+            sendJson(res, { fields: profileFieldDescriptors(model) });
+            return true;
+        }
+        if (route === "/__host/model/profile" && method === "GET") {
+            handleProfileGet(res, model);
+            return true;
+        }
+        if (route === "/__host/model/budget" && method === "GET") {
+            handleBudget(res, model, params);
+            return true;
+        }
+        if (route === "/__host/model/profile" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleProfileSet(req, res, model);
+            return true;
+        }
+        if (route === "/__host/model/load" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleLoad(res, model);
+            return true;
+        }
+        if (route === "/__host/model" && method === "DELETE") {
+            if (!guardWrite(res))
+                return true;
+            handleDelete(res, model);
+            return true;
+        }
+        if (route === "/__host/model" && method === "GET") {
+            // A single inventory row, for a detail pane that does not want the whole list.
+            void (async () => {
+                try {
+                    const gpu = await deps.queryGpuInfo();
+                    sendJson(res, buildInventoryRow({
+                        model,
+                        store: deps.getProfilesStore(),
+                        defaults: deps.getProfileDefaults(),
+                        gpu,
+                        ranking: deps.getRanking(),
+                        supervisor: deps.supervisor,
+                    }));
+                }
+                catch (error) {
+                    sendError(res, 500, errorMessage(error));
+                }
+            })();
+            return true;
+        }
+        sendError(res, 405, `${method} is not allowed on ${route}`);
+        return true;
+    }
+    return { handle: handleHostApi, capabilities };
+}
+/** The delete plan without performing it, for a confirmation dialog. */
+export function describeDelete(model) {
+    return planDelete(model);
+}
+//# sourceMappingURL=host-api.js.map

package/dist/service/http-util.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The small HTTP primitives the service layer shares.
+ *
+ * These lived inside `router.ts` while it was the only thing serving requests.
+ * `host-api.ts` needs the same error envelope and the same bounded body reader,
+ * and importing them back out of `router.ts` would make a cycle, so they sit
+ * here. The error envelope is deliberately Anthropic-shaped: clients already
+ * parse that from the completion proxy, so a management-endpoint failure does
+ * not need a second error format.
+ */
+import type http from "node:http";
+/** Headers that must not be forwarded across a proxy hop. */
+export declare const HOP_BY_HOP: Set<string>;
+export declare function errorBody(status: number, message: string): string;
+export declare function sendJson(res: http.ServerResponse, payload: unknown, status?: number): void;
+export declare function sendError(res: http.ServerResponse, status: number, message: string): void;
+export type JsonBodyResult = {
+    ok: true;
+    body: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/** Buffer a bounded JSON request body. */
+export declare function readJsonBody(req: http.IncomingMessage, limit: number, cb: (result: JsonBodyResult) => void): void;
+export declare function errorMessage(error: unknown): string;
+//# sourceMappingURL=http-util.d.ts.map

package/dist/service/http-util.js

@@ -0,0 +1,72 @@
+/** Headers that must not be forwarded across a proxy hop. */
+export const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+export function errorBody(status, message) {
+    return JSON.stringify({
+        type: "error",
+        error: { type: status === 503 ? "overloaded_error" : "api_error", message },
+    });
+}
+export function sendJson(res, payload, status = 200) {
+    const body = JSON.stringify(payload, null, 2);
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(body),
+    });
+    res.end(body);
+}
+export function sendError(res, status, message) {
+    if (res.headersSent) {
+        if (!res.writableEnded)
+            res.destroy();
+        return;
+    }
+    const body = errorBody(status, message);
+    const headers = {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(body),
+    };
+    if (status === 503)
+        headers["retry-after"] = "5";
+    res.writeHead(status, headers);
+    res.end(body);
+}
+/** Buffer a bounded JSON request body. */
+export function readJsonBody(req, limit, cb) {
+    const chunks = [];
+    let size = 0;
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > limit)
+            tooBig = true;
+        else
+            chunks.push(chunk);
+    });
+    req.on("error", () => cb({ ok: false, error: "request stream error" }));
+    req.on("end", () => {
+        if (tooBig) {
+            cb({ ok: false, error: "request body too large" });
+            return;
+        }
+        try {
+            const text = Buffer.concat(chunks).toString("utf8") || "{}";
+            cb({ ok: true, body: JSON.parse(text) });
+        }
+        catch {
+            cb({ ok: false, error: "invalid JSON body" });
+        }
+    });
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=http-util.js.map

package/dist/service/model-selector.d.ts

@@ -11,7 +11,7 @@ export interface SelectCodingModelOptions {
     /** Track A's per-model bench ranking (mean score + runs + std). */
     ranking: RankedModel[];
     /**
-     * VRAM-fit predicate. Omit (or pass undefined) to skip the fit filter — the
+     * VRAM-fit predicate. Omit (or pass undefined) to skip the fit filter - the
      * caller does this when GPU info is absent, mirroring serve.ts's "absent →
      * skip" behaviour.
      */
@@ -23,7 +23,7 @@ export interface SelectCodingModelOptions {
 }
 /**
  * Pick the best-ranked coding model that fits the VRAM budget. Pure and
- * deterministic — no IO, no clock, no randomness.
+ * deterministic - no IO, no clock, no randomness.
  */
 export declare function selectCodingModel({ models, ranking, fits, preferLoadedId, fallback, }: SelectCodingModelOptions): Model | null;
 /**

package/dist/service/model-selector.js

@@ -2,13 +2,13 @@
  * Route-time model selection for the UNNAMED request path.
  *
  * When a client hits the brain without naming a model, the old default served
- * "whatever is loaded, else catalog[0]" — blind to which local model is actually
+ * "whatever is loaded, else catalog[0]" - blind to which local model is actually
  * the best coder. This picks the best-ranked coding-capable model that fits the
  * VRAM budget instead, wiring together Track A (the bench ranking) and Track B1
  * (the catalog coding metadata carried onto the scanned Model).
  *
  * `selectCodingModel` is PURE: it takes the models, the ranking, an optional
- * VRAM-fit predicate, and a fallback, and returns the chosen model with no IO —
+ * VRAM-fit predicate, and a fallback, and returns the chosen model with no IO -
  * so the decision logic is trivially testable. `makeVramFitPredicate` is the one
  * impure edge (it reads GPU total VRAM and runs a vram.budget), deliberately kept
  * out of the pure path.
@@ -19,7 +19,7 @@ import * as vram from "../vram.js";
 // it is backed by enough repeated runs and its spread across those runs is
 // tight. rankModels reports one entry per model with the MEAN overall score
 // (0..1), the run COUNT, and the sample STD (also 0..1). A single run has std 0
-// — falsely confident — so we require at least two runs, and we reject a mean
+// - falsely confident - so we require at least two runs, and we reject a mean
 // whose runs disagree by more than MAX_TRUSTED_STD. Untrusted models stay
 // eligible but sort below every trusted one.
 export const MIN_TRUSTED_RUNS = 2;
@@ -77,17 +77,17 @@ function compareCandidates(a, b, preferLoadedId) {
 }
 /**
  * Pick the best-ranked coding model that fits the VRAM budget. Pure and
- * deterministic — no IO, no clock, no randomness.
+ * deterministic - no IO, no clock, no randomness.
  */
 export function selectCodingModel({ models, ranking, fits, preferLoadedId = null, fallback, }) {
     if (models.length === 0)
         return fallback;
     // 1. Candidate set: coding-capable models. If nothing is tagged (a catalog
-    //    with no coding metadata, or hand-placed models), don't fail closed —
+    //    with no coding metadata, or hand-placed models), don't fail closed -
     //    fall back to the whole set.
     const tagged = models.filter(isCodingCapable);
     let candidates = tagged.length > 0 ? tagged : models;
-    // 2. VRAM fit filter (skipped when no predicate — i.e. GPU info absent). If
+    // 2. VRAM fit filter (skipped when no predicate - i.e. GPU info absent). If
     //    nothing coding-capable fits, keep the existing default rather than
     //    forcing a model that overflows the budget.
     if (fits) {

package/dist/service/router.d.ts

@@ -3,6 +3,7 @@ import type { Supervisor } from "./supervisor.js";
 import { type RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
 import type { Profile } from "../config/schema.js";
+import type { HostApi } from "./host-api.js";
 type Verdict = "ok" | "reasoning-only" | "truncated" | "failed";
 /** A logger sink; only `warn` is used by the router. */
 export interface Logger {
@@ -46,8 +47,17 @@ export declare class Telemetry {
     totals: TelemetryTotals;
     constructor(keep?: number);
     record(entry: TelemetryRecord): void;
-    /** Advice derived from observed behaviour, not guesswork. */
+    /**
+     * Advice derived from the recent window (`records`), not lifetime `totals`.
+     * A ratio over the lifetime total barely moves once a service has served any
+     * real volume, so a handful of clean responses after a bad patch could never
+     * clear it. The sliding window lets a few good requests visibly clear the
+     * advice, and `reset()` gives a restarted model a clean slate instead of
+     * carrying blame from before the fix was applied.
+     */
     get warning(): string | null;
+    /** Clear the recent window so the warning starts fresh - called when the model (re)starts. */
+    reset(): void;
 }
 /** Classify a completion body (Anthropic or OpenAI shaped). */
 export declare function analyse(bodyText: string): Analysis | null;
@@ -118,9 +128,9 @@ export interface RouterOptions {
     queryGpuInfo?: () => Promise<GpuInfo | null>;
     /** The brain package version, reported on `/__host/status` for the host UI. */
     version?: string | null;
-    /** Effective config with secrets redacted — served on `/__host/config`. */
+    /** Effective config with secrets redacted - served on `/__host/config`. */
     getConfig?: (() => unknown) | null;
-    /** Benchmark rankings/variance/latest — served on `/__host/evals`. */
+    /** Benchmark rankings/variance/latest - served on `/__host/evals`. */
     getEvals?: (() => unknown) | null;
     /** Live: pin the host to one model (refuse completions naming a different one). */
     getLockModel?: () => boolean;
@@ -138,7 +148,21 @@ export interface RouterOptions {
      * until its owner opts in. Read/use are unaffected.
      */
     getAllowConfigWrite?: () => boolean;
+    /**
+     * The management API (`host-api.ts`): model inventory, per-model profiles, the
+     * VRAM budget, load/unload, delete, and logs. Absent means those routes are not
+     * offered, which is exactly what `/__host/capabilities` then reports, so an
+     * older brain degrades to "that tab is unavailable" rather than a 404 storm.
+     */
+    hostApi?: HostApi | null;
+    /**
+     * Live system telemetry (CPU, RAM, GPU, slots), folded into `/__host/status`
+     * ONLY when the caller asks with `?resources=1`. The daemon's liveness probe
+     * polls status frequently and must not pay an `nvidia-smi` spawn for it; the
+     * Brain page's Overview tab opts in.
+     */
+    getResources?: (() => Promise<unknown>) | null;
 }
-export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, hostApi, getResources, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
 export {};
 //# sourceMappingURL=router.d.ts.map