dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/routes/chat-template.d.ts

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/chat-template.js

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/deps.d.ts

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/deps.js

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/download.d.ts

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/download.js

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/get.d.ts

@@ -0,0 +1 @@
+

package/packages/ui/lib/routes/get.js

@@ -0,0 +1,106 @@
+/**
+ * The POST /local-infer/get route: the Get step. Its answer streams as
+ * NDJSON progress events only (a structured download state folded from the
+ * hf download's tqdm stderr): the run's log text reaches the card through
+ * the per-provider run-log stream (the GET /local-infer/logs route fed by the
+ * hub), so one line never arrives twice. The full run still collects,
+ * persists as the last-run logs in plain text, and feeds the live hub, so
+ * the log file, the Logs section, and the streamed run read the run the same
+ * way.
+ * @module dsh-plugin-local-infer/ui/routes/get
+ */
+import { runLogKey } from '../../../service/lib/index.js';
+import { parseStoredPlatformConfig } from "../config.js";
+import { CANCELED_LINE, GET_EVENT_PREFIX, getEngine, resolveStoredRequest } from "../ops/engine.js";
+import { captureRunBaseline, finishRunSection, GET_RUN_SEED } from "../ops/logs.js";
+import { defineRoute } from "../route.js";
+import { abortOnResponseClose, ndjsonLine, throttledProgressSink } from "./stream.js";
+/**
+ * getRoute builds the POST /local-infer/get route definition the register
+ * step holds by an effect. The optional getHost is the lifecycle host the
+ * git and build steps run through; it defaults to the node host, and a test
+ * injects a stub so the route never clones a real repo in CI.
+ */
+export function getRoute(localInfer, getHost) {
+    return defineRoute({
+        name: 'local-infer-get',
+        path: '/local-infer/get',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'get payload too large',
+        run: async ({ body }, res) => {
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (body.config && typeof body.config === 'object') {
+                request.config = body.config;
+            }
+            const platform = parseStoredPlatformConfig(body.platform);
+            if (platform !== undefined) {
+                request.platform = platform;
+            }
+            res.ndjsonStream();
+            // The run key the live hub buffers this Get under, the shared runLogKey
+            // rule (the request names no provider, so the stored entry matching the
+            // engine and model wins, and a draft falls back to the engine id).
+            const { stored, engineId, config } = resolveStoredRequest(request);
+            const runKey = runLogKey(stored.providers, engineId, undefined, config);
+            localInfer.beginRun(runKey, GET_RUN_SEED);
+            // The stored last-run logs as they stand before the run persists
+            // anything: the sudo observer persists its note while the run hangs on
+            // the prompt, and finishRunSection closes the run over the baseline so
+            // that provisional line and the collected run text persist once.
+            const baseline = captureRunBaseline();
+            let collected = '';
+            // The log sink collects the plain-text run (the persisted log) and
+            // appends the same chunk to the live hub, whose run-log stream carries
+            // the text to the card's Logs pane (Q2: one streamed display path).
+            // The route's own answer no longer mirrors the text as log events, so
+            // a line never lands twice.
+            const log = (text) => {
+                collected += text;
+                localInfer.appendRunLog(runKey, text);
+            };
+            // The hf download's raw stderr sink: the core chunk folder turns the
+            // tqdm lines into a structured state, and the sink emits a progress
+            // event when a fold yields one (throttled to the half-second cadence).
+            const onChunk = throttledProgressSink((progress) => ndjsonLine(res, { progress }));
+            // The card's provider-form Cancel aborts the fetch, which closes the
+            // response: the abort interrupts the in-flight hf child (SIGINT, then
+            // SIGTERM). Resume is within-invocation only; a killed run re-downloads
+            // from zero on the re-run (the orphaned .incomplete blob lingers until
+            // `hf cache prune`). A close after the run settled is the normal end,
+            // not a cancel.
+            const { signal, markFinished } = abortOnResponseClose(res);
+            try {
+                try {
+                    await getEngine(localInfer, request, log, getHost, signal, onChunk);
+                }
+                catch (error) {
+                    log(`${GET_EVENT_PREFIX}get failed: ${String(error?.message ?? error)}\n`);
+                }
+                // A cancel that closed the stream appends the "Canceled" line, so the
+                // persisted run (and the log file) read the run as canceled, the same
+                // line the card writes to its Logs buffer on the Cancel.
+                if (signal.aborted) {
+                    log(`${CANCELED_LINE}`);
+                }
+                markFinished();
+                // The "Getting engine and model..." separator leads the persisted
+                // run and the live run's seed, so the Logs section, the log file, and
+                // the streamed run read the run as one fresh process section.
+                // finishRunSection closes the run over the baseline captured before
+                // it started, not a second append over its own provisional notes.
+                finishRunSection(baseline, `${GET_RUN_SEED}${collected}`);
+                res.end();
+            }
+            finally {
+                // The bracket closes on every settle path, cancel and failure
+                // included: the key's running flag clears after finishRunSection.
+                localInfer.endRun(runKey);
+            }
+        },
+    });
+}
+//# sourceMappingURL=get.js.map

package/packages/ui/lib/routes/install.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The POST /local-infer/install route: the Play/Run path. It refuses with a
+ * 409 while the trust gate is off (the copy/paste path is always the
+ * fallback), runs the install through the service, and answers with the
+ * install result and the refreshed deps model, so the card re-renders the
+ * gate from the same re-check the install ran.
+ * @module dsh-plugin-local-infer/ui/routes/install
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * installRoute builds the POST /local-infer/install route definition the
+ * register step holds by an effect.
+ */
+export declare function installRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=install.d.ts.map

package/packages/ui/lib/routes/install.js

@@ -0,0 +1,36 @@
+/**
+ * The POST /local-infer/install route: the Play/Run path. It refuses with a
+ * 409 while the trust gate is off (the copy/paste path is always the
+ * fallback), runs the install through the service, and answers with the
+ * install result and the refreshed deps model, so the card re-renders the
+ * gate from the same re-check the install ran.
+ * @module dsh-plugin-local-infer/ui/routes/install
+ */
+import { defineRoute } from "../route.js";
+import { runInstallFor } from "../viewmodels/depsHelpers.js";
+/**
+ * installRoute builds the POST /local-infer/install route definition the
+ * register step holds by an effect.
+ */
+export function installRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-install',
+        path: '/local-infer/install',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'install payload too large',
+        run: async ({ body }, res) => {
+            // exactOptionalPropertyTypes: build the request object with only the
+            // keys that are present, so an absent value never writes `undefined`.
+            const request = {};
+            if (typeof body.engine === 'string') {
+                request.engine = body.engine;
+            }
+            if (body.config && typeof body.config === 'object') {
+                request.config = body.config;
+            }
+            res.json(200, await runInstallFor(localInfer, request));
+        },
+    });
+}
+//# sourceMappingURL=install.js.map

package/packages/ui/lib/routes/launch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The POST /local-infer/launch route: it renders the plan the registered
+ * adapter produces and runs the service's launch entry point (deploy, then
+ * the health poll). The launch streams its progress as NDJSON: a step event
+ * as each phase (prereqs, download, build, launch) begins, a progress event
+ * when the Get-steps hf download's tqdm stderr folds into a structured
+ * state, a sudo event when a guarded command waits for the user's password
+ * on the launching CLI, then a final result event. The card's Launch control
+ * reads the step that is running and times out only the launch (health-poll)
+ * step; the rebuild steps run as long as they need to.
+ * @module dsh-plugin-local-infer/ui/routes/launch
+ */
+import type { LifecycleHost } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * launchRoute builds the POST /local-infer/launch route definition the
+ * register step holds by an effect. The optional launchHost is the lifecycle
+ * host the launch's Get steps (git sync, build) run through; it defaults to
+ * the node host, and a test injects a stub so the route never clones a real
+ * repo in CI.
+ */
+export declare function launchRoute(localInfer: LocalInferService, launchHost?: LifecycleHost): LocalInferRoute;
+//# sourceMappingURL=launch.d.ts.map

package/packages/ui/lib/routes/launch.js

@@ -0,0 +1,74 @@
+/**
+ * The POST /local-infer/launch route: it renders the plan the registered
+ * adapter produces and runs the service's launch entry point (deploy, then
+ * the health poll). The launch streams its progress as NDJSON: a step event
+ * as each phase (prereqs, download, build, launch) begins, a progress event
+ * when the Get-steps hf download's tqdm stderr folds into a structured
+ * state, a sudo event when a guarded command waits for the user's password
+ * on the launching CLI, then a final result event. The card's Launch control
+ * reads the step that is running and times out only the launch (health-poll)
+ * step; the rebuild steps run as long as they need to.
+ * @module dsh-plugin-local-infer/ui/routes/launch
+ */
+import { nodeLifecycleHost } from '../../../providers/lib/index.js';
+import { launchEngine } from "../ops/engine.js";
+import { defineRoute, RouteError } from "../route.js";
+import { launchRequestFromBody } from "../request.js";
+import { abortOnResponseClose, ndjsonLine, throttledProgressSink } from "./stream.js";
+/**
+ * launchRoute builds the POST /local-infer/launch route definition the
+ * register step holds by an effect. The optional launchHost is the lifecycle
+ * host the launch's Get steps (git sync, build) run through; it defaults to
+ * the node host, and a test injects a stub so the route never clones a real
+ * repo in CI.
+ */
+export function launchRoute(localInfer, launchHost = nodeLifecycleHost) {
+    return defineRoute({
+        name: 'local-infer-launch',
+        path: '/local-infer/launch',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'launch payload too large',
+        run: async ({ body }, res) => {
+            res.ndjsonStream();
+            const writeLine = (line) => {
+                ndjsonLine(res, line);
+            };
+            const onProgress = (step) => {
+                writeLine({ step });
+            };
+            // The Get-steps hf download's raw stderr sink: the core chunk folder
+            // turns the tqdm lines into a structured state, and the sink emits a
+            // progress event when a fold yields one (throttled to the half-second
+            // cadence), between the step and result events.
+            const onChunk = throttledProgressSink((progress) => writeLine({ progress }));
+            // The run's sudo observer calls this when a guarded command waits for
+            // the password on the launching CLI (see launchEngine): the card reads
+            // the line as "Sudo needed" on its Launch control.
+            const onSudo = () => {
+                writeLine({ sudo: true });
+            };
+            // The card's provider-form Cancel aborts the fetch, which closes the
+            // response: the abort interrupts the in-flight Get-step hf child
+            // (SIGINT, then SIGTERM), and the persisted run carries the "Canceled"
+            // line. A close after the run settled is the normal end, not a cancel.
+            const { signal, markFinished } = abortOnResponseClose(res);
+            try {
+                const result = await launchEngine(localInfer, launchRequestFromBody(body), onProgress, launchHost, signal, onChunk, onSudo);
+                writeLine({ result });
+            }
+            catch (error) {
+                // A launch that breaks before a plan renders (an unknown engine, a
+                // hardware probe failure) still settles the card's control to the red
+                // Logs state through a result event, not a bare 500.
+                const detail = error instanceof RouteError
+                    ? error.message
+                    : String(error?.message ?? error);
+                writeLine({ result: { healthy: false, detail } });
+            }
+            markFinished();
+            res.end();
+        },
+    });
+}
+//# sourceMappingURL=launch.js.map

package/packages/ui/lib/routes/logs.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The GET /local-infer/logs route: the per-provider live run-log stream the
+ * card's Logs pane holds open (Q2: all live log display streams, nothing
+ * polls). The handler subscribes to the run-log hub before reading the
+ * catch-up snapshot, so an append that lands between the two is deduped by
+ * seq against the snapshot instead of doubling or being lost. One attached
+ * connection sees, in order: one `{ snapshot, seq, running }` catch-up line,
+ * then one `{ log, seq }` line per append, a `{ runBegin, seq }` line when a
+ * new run resets the buffer (the pane replaces, never appends), and a
+ * `{ runEnd, seq }` line when the run settles. The connection stays attached
+ * across runs. An unknown or blank provider key streams the empty snapshot
+ * and stays attached, so a client racing a run start never sees a 404; the
+ * client disconnect disposes the hub subscription.
+ * @module dsh-plugin-local-infer/ui/routes/logs
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * LogsStreamEvent is one NDJSON line the logs route streams: the catch-up
+ * snapshot (the bounded buffer text, the seq it reached, the running flag),
+ * one appended chunk, a run begin (the new run's seed line, seq back at 0,
+ * so the pane replaces its display), or the run end (the seq it settled at).
+ * Every line carries the seq the next append continues, so the card can drop
+ * any line whose seq the text it holds already covers.
+ */
+export type LogsStreamEvent = {
+    snapshot: string;
+    seq: number;
+    running: boolean;
+} | {
+    log: string;
+    seq: number;
+} | {
+    runBegin: string;
+    seq: number;
+} | {
+    runEnd: true;
+    seq: number;
+};
+/**
+ * LogsStreamRoute is the logs route's definition plus the open-stream
+ * registry the route effect's disposer drains. A bundle switch off
+ * unregisters the route, but browser panes that still hold a stream open
+ * leave their hub subscriptions behind unless something closes them; the
+ * effect disposer calls closeOpenStreams for that.
+ */
+export interface LogsStreamRoute extends LocalInferRoute {
+    closeOpenStreams(): void;
+}
+/**
+ * logsRoute builds the GET /local-infer/logs?provider=<key> route definition
+ * the register step holds by an effect. The `provider` query is the run key
+ * every run path shares (the runLogKey rule the card's requests mirror); a
+ * missing or unknown key is a live stream of nothing until someone runs it.
+ */
+export declare function logsRoute(localInfer: LocalInferService): LogsStreamRoute;
+//# sourceMappingURL=logs.d.ts.map

package/packages/ui/lib/routes/logs.js

@@ -0,0 +1,117 @@
+/**
+ * The GET /local-infer/logs route: the per-provider live run-log stream the
+ * card's Logs pane holds open (Q2: all live log display streams, nothing
+ * polls). The handler subscribes to the run-log hub before reading the
+ * catch-up snapshot, so an append that lands between the two is deduped by
+ * seq against the snapshot instead of doubling or being lost. One attached
+ * connection sees, in order: one `{ snapshot, seq, running }` catch-up line,
+ * then one `{ log, seq }` line per append, a `{ runBegin, seq }` line when a
+ * new run resets the buffer (the pane replaces, never appends), and a
+ * `{ runEnd, seq }` line when the run settles. The connection stays attached
+ * across runs. An unknown or blank provider key streams the empty snapshot
+ * and stays attached, so a client racing a run start never sees a 404; the
+ * client disconnect disposes the hub subscription.
+ * @module dsh-plugin-local-infer/ui/routes/logs
+ */
+import { defineRoute } from "../route.js";
+import { ndjsonLine } from "./stream.js";
+/**
+ * logsRoute builds the GET /local-infer/logs?provider=<key> route definition
+ * the register step holds by an effect. The `provider` query is the run key
+ * every run path shares (the runLogKey rule the card's requests mirror); a
+ * missing or unknown key is a live stream of nothing until someone runs it.
+ */
+export function logsRoute(localInfer) {
+    // One closer per attached connection, so the effect disposer can detach
+    // every stream still open when the bundle switches off.
+    const openConnections = new Set();
+    const route = defineRoute({
+        name: 'local-infer-logs',
+        path: '/local-infer/logs',
+        method: 'GET',
+        failStatus: 500,
+        run: async ({ url }, res) => {
+            res.ndjsonStream();
+            const key = url.searchParams.get('provider') ?? '';
+            // The highest hub seq the client's text already covers: the snapshot
+            // line, then every forwarded log append. A log event at or below it is
+            // already in text the client holds, so it is dropped.
+            let coveredSeq = 0;
+            // True until the snapshot line is on the wire. Hub events that land in
+            // the window between subscribe and the snapshot read queue here and
+            // then run through the same seq rule, so the snapshot is always the
+            // stream's first line.
+            let catchingUp = true;
+            const queued = [];
+            // A client disconnect stops forwarding before the hub hands another
+            // event to a write on the closed response.
+            let closed = false;
+            const forward = (event) => {
+                if (event.kind === 'log') {
+                    if (event.seq <= coveredSeq)
+                        return;
+                    coveredSeq = event.seq;
+                    ndjsonLine(res, { log: event.text, seq: event.seq });
+                    return;
+                }
+                if (event.kind === 'reset') {
+                    // A new run restarted the key's seq at 0 with the seed line; the
+                    // pane replaces its buffer, and the seq count restarts with it.
+                    coveredSeq = event.seq;
+                    ndjsonLine(res, { runBegin: event.text, seq: event.seq });
+                    return;
+                }
+                ndjsonLine(res, { runEnd: true, seq: event.seq });
+            };
+            // Subscribe first, then read: an append racing between the two is
+            // caught by the listener (queued) and deduped against the snapshot
+            // that already holds its text, never lost or doubled.
+            const dispose = localInfer.subscribeRunLog(key, (event) => {
+                if (closed)
+                    return;
+                if (catchingUp) {
+                    queued.push(event);
+                    return;
+                }
+                forward(event);
+            });
+            const snapshot = localInfer.readRunLog(key);
+            coveredSeq = snapshot.seq;
+            ndjsonLine(res, {
+                snapshot: snapshot.text,
+                seq: snapshot.seq,
+                running: snapshot.running,
+            });
+            catchingUp = false;
+            for (const event of queued) {
+                forward(event);
+            }
+            // The bundle switching off while this pane still streams: end the
+            // response and drop the hub subscription, so no listener outlives the
+            // route it was opened by (the effect disposer runs closeOpenStreams).
+            const closeConnection = () => {
+                closed = true;
+                dispose();
+                openConnections.delete(closeConnection);
+                res.end();
+            };
+            openConnections.add(closeConnection);
+            // The card unmounting or refreshing closes the response: dispose the
+            // subscription so a gone pane never leaves a listener behind.
+            res.onClose(() => {
+                closed = true;
+                dispose();
+                openConnections.delete(closeConnection);
+            });
+        },
+    });
+    return {
+        ...route,
+        closeOpenStreams() {
+            for (const closeConnection of [...openConnections]) {
+                closeConnection();
+            }
+        },
+    };
+}
+//# sourceMappingURL=logs.js.map

package/packages/ui/lib/routes/provider-delete.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The POST /local-infer/provider-delete route: it removes the stored
+ * provider entry named by the body's id, keeps the rest of the list and the
+ * active config intact, and re-syncs the service's platform registry so a
+ * launch never reads a platform config the user just removed.
+ * @module dsh-plugin-local-infer/ui/routes/provider-delete
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * providerDeleteRoute builds the POST /local-infer/provider-delete route
+ * definition the register step holds by an effect.
+ */
+export declare function providerDeleteRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=provider-delete.d.ts.map

package/packages/ui/lib/routes/provider-delete.js

@@ -0,0 +1,37 @@
+/**
+ * The POST /local-infer/provider-delete route: it removes the stored
+ * provider entry named by the body's id, keeps the rest of the list and the
+ * active config intact, and re-syncs the service's platform registry so a
+ * launch never reads a platform config the user just removed.
+ * @module dsh-plugin-local-infer/ui/routes/provider-delete
+ */
+import { readConfig, writeConfig } from "../config.js";
+import { syncPlatformConfigs } from "../ops/engine.js";
+import { defineRoute } from "../route.js";
+import { buildSummary } from "../viewmodels/summary.js";
+/**
+ * providerDeleteRoute builds the POST /local-infer/provider-delete route
+ * definition the register step holds by an effect.
+ */
+export function providerDeleteRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-provider-delete',
+        path: '/local-infer/provider-delete',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'payload too large',
+        run: async ({ body }, res) => {
+            const id = typeof body.id === 'string' ? body.id : undefined;
+            if (id === undefined) {
+                res.json(400, { error: 'the provider id is required' });
+                return;
+            }
+            const stored = readConfig();
+            const providers = stored.providers.filter((entry) => entry.id !== id);
+            writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, stored.lastLogs);
+            syncPlatformConfigs(localInfer, stored);
+            res.json(200, await buildSummary(localInfer));
+        },
+    });
+}
+//# sourceMappingURL=provider-delete.js.map

package/packages/ui/lib/routes/register.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The POST /local-infer/register route: it renders the plan through the
+ * registered adapter, resolves the model row and the context window, and
+ * runs the service's register entry point, which upserts the provider and
+ * model through the settings seam. The result carries the entry the
+ * registrar wrote, so the card names the model it published.
+ * @module dsh-plugin-local-infer/ui/routes/register
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * registerRoute builds the POST /local-infer/register route definition the
+ * register step holds by an effect.
+ */
+export declare function registerRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=register.d.ts.map

package/packages/ui/lib/routes/register.js

@@ -0,0 +1,28 @@
+/**
+ * The POST /local-infer/register route: it renders the plan through the
+ * registered adapter, resolves the model row and the context window, and
+ * runs the service's register entry point, which upserts the provider and
+ * model through the settings seam. The result carries the entry the
+ * registrar wrote, so the card names the model it published.
+ * @module dsh-plugin-local-infer/ui/routes/register
+ */
+import { registerFor } from "../ops/model.js";
+import { defineRoute } from "../route.js";
+import { registerRequestFromBody } from "../request.js";
+/**
+ * registerRoute builds the POST /local-infer/register route definition the
+ * register step holds by an effect.
+ */
+export function registerRoute(localInfer) {
+    return defineRoute({
+        name: 'local-infer-register',
+        path: '/local-infer/register',
+        method: 'POST',
+        failStatus: 500,
+        tooLargeMessage: 'register payload too large',
+        run: async ({ body }, res) => {
+            res.json(200, await registerFor(localInfer, registerRequestFromBody(body)));
+        },
+    });
+}
+//# sourceMappingURL=register.js.map

package/packages/ui/lib/routes/save.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The POST /local-infer/save route: it upserts a provider entry (an id
+ * updates the stored entry in place, an absent id updates a stored entry that
+ * already matches the engine, config, and platform in place, and only a save
+ * with no match mints a new id and prepends the entry), persists the global
+ * fields the card's toggles edit, re-syncs the service's platform registry with
+ * the saved map, and re-runs the registration for an already-registered model
+ * so its input types stay in step with the saved config.
+ * @module dsh-plugin-local-infer/ui/routes/save
+ */
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { LocalInferRoute } from '../route.ts';
+/**
+ * saveRoute builds the POST /local-infer/save route definition the register
+ * step holds by an effect.
+ */
+export declare function saveRoute(localInfer: LocalInferService): LocalInferRoute;
+//# sourceMappingURL=save.d.ts.map