@mlx-node/server 0.0.8 → 0.0.9

package/dist/health.js

@@ -0,0 +1,107 @@
+/**
+ * Server readiness reporting for supervisors (e.g. an Electron app running
+ * the inference server as a child process).
+ *
+ * The old `/health` returned a constant `{ status: 'ok' }`, which cannot
+ * distinguish four states a supervisor genuinely needs to tell apart:
+ *
+ *   - up, nothing loaded          → keep waiting, this is normal
+ *   - up, model resident          → route traffic
+ *   - wedged mid-load             → keep waiting, do NOT restart
+ *   - wedged behind a full queue  → shed load / warn the user
+ *
+ * Every input already exists in-process; this module only exposes it. The
+ * status ladder itself is a PURE function ({@link deriveHealthStatus}) over a
+ * plain record so it can be unit-tested without a server, a registry, or the
+ * native addon.
+ *
+ * IMPORTANT: nothing here may call into `@mlx-node/core`. `/health` is
+ * deliberately excluded from the idle sweeper's `beginRequest`/`endRequest`
+ * bracket (see `HandlerOptions.idleSweeper`), so a native call from this path
+ * would run outside the in-flight accounting the drain timer relies on.
+ * Every field below is read from plain JavaScript state.
+ */
+/**
+ * Pure status ladder. No I/O, no clock, no native calls — just the four
+ * documented rungs, in precedence order:
+ *
+ *   1. `writerActive`                        → 'loading'
+ *   2. last load failed AND nothing resident → 'error'
+ *   3. queue saturated, OR a load is parked
+ *      behind live inference                 → 'degraded'
+ *   4. otherwise                             → 'ok'
+ *
+ * `'loading'` outranks `'error'` on purpose: a retry that already holds the
+ * writer slot means the supervisor should wait, not restart the process.
+ */
+export function deriveHealthStatus(input) {
+    if (input.writerActive)
+        return 'loading';
+    if (input.lastLoad?.ok === false && input.residentModelCount === 0)
+        return 'error';
+    if (input.queueSaturated)
+        return 'degraded';
+    // A writer parked while readers are still running means the swap cannot
+    // proceed until they drain, and every request for the incoming model
+    // stalls behind it. Either condition alone is an ordinary transient.
+    if (input.waitingWriters > 0 && input.inFlight > 0)
+        return 'degraded';
+    return 'ok';
+}
+/** Project the full body down to the three fields safe to serve without a token. */
+export function toMinimalHealth(health) {
+    return { status: health.status, uptimeMs: health.uptimeMs, pid: health.pid };
+}
+/**
+ * Build a zero-argument reporter closing over the live server objects. Each
+ * call re-reads current state; nothing is cached, so a supervisor polling on
+ * an interval always sees the present moment.
+ */
+export function createHealthReporter(deps) {
+    const now = deps.now ?? (() => Date.now());
+    const startedAt = deps.startedAt ?? now();
+    return () => {
+        const resident = deps.registry.list().map((entry) => entry.id);
+        // Queue saturation is inherently per-model: one wedged model should
+        // surface even while others are idle. We report the WORST case.
+        let depth = 0;
+        let limit = null;
+        let saturated = false;
+        for (const sessionRegistry of deps.registry.listSessionRegistries()) {
+            const registryDepth = sessionRegistry.queueDepth;
+            if (registryDepth > depth)
+                depth = registryDepth;
+            const registryLimit = sessionRegistry.queueDepthLimit;
+            if (registryLimit !== undefined) {
+                if (limit === null || registryLimit < limit)
+                    limit = registryLimit;
+                if (registryDepth >= registryLimit)
+                    saturated = true;
+            }
+        }
+        const writerActive = deps.modelWorkCoordinator?.writerActive ?? false;
+        const waitingWriters = deps.modelWorkCoordinator?.waitingWriters ?? 0;
+        const lastLoad = deps.modelWorkCoordinator?.lastLoad ?? null;
+        const inFlight = deps.idleSweeper?.inFlight ?? 0;
+        const drainPending = deps.idleSweeper?.isPending ?? false;
+        const status = deriveHealthStatus({
+            writerActive,
+            waitingWriters,
+            inFlight,
+            residentModelCount: resident.length,
+            queueSaturated: saturated,
+            lastLoad,
+        });
+        return {
+            status,
+            // Clamped: a backwards clock step (NTP, fake timers in a sibling test)
+            // must not surface a negative uptime a supervisor might read as a wrap.
+            uptimeMs: Math.max(0, now() - startedAt),
+            pid: process.pid,
+            models: { resident, count: resident.length },
+            work: { inFlight, drainPending, writerActive, waitingWriters },
+            queue: { depth, limit, saturated },
+            lastLoad,
+        };
+    };
+}

package/dist/host/discover.d.ts

@@ -0,0 +1,19 @@
+/** Discover locally-downloaded generative models under a given directory. */
+import { type ModelType } from '@mlx-node/lm';
+import { type LaunchPreset } from '../presets.js';
+/** A locally-downloaded model paired with its sampling preset. */
+export interface DiscoveredModel {
+    name: string;
+    path: string;
+    modelType: ModelType;
+    preset: LaunchPreset;
+}
+/**
+ * Scan `dir` for model subdirectories. Each subdirectory with a recognized
+ * `config.json` is returned with its inferred `ModelType` and `LaunchPreset`.
+ * Non-generative types are silently skipped. Entries with no preset or an
+ * undetectable config are skipped (warnings only emitted when `MLX_DEBUG`
+ * is set). Must stay cheap — do not load weights here.
+ */
+export declare function discoverModels(dir: string): Promise<DiscoveredModel[]>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/host/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/host/discover.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAM7E,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAElE,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;CACtB;AAKD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAoC5E"}

package/dist/host/discover.js

@@ -0,0 +1,50 @@
+/** Discover locally-downloaded generative models under a given directory. */
+import { readdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { detectModelType } from '@mlx-node/lm';
+import { LAUNCH_PRESETS } from '../presets.js';
+// Non-generative detection results that cannot back a chat endpoint.
+const NON_GENERATIVE = new Set(['harrier', 'qianfan-ocr', 'internvl_chat']);
+/**
+ * Scan `dir` for model subdirectories. Each subdirectory with a recognized
+ * `config.json` is returned with its inferred `ModelType` and `LaunchPreset`.
+ * Non-generative types are silently skipped. Entries with no preset or an
+ * undetectable config are skipped (warnings only emitted when `MLX_DEBUG`
+ * is set). Must stay cheap — do not load weights here.
+ */
+export async function discoverModels(dir) {
+    const debug = Boolean(process.env.MLX_DEBUG);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const full = join(dir, entry.name);
+        let modelType;
+        try {
+            modelType = await detectModelType(full);
+        }
+        catch (err) {
+            if (debug)
+                console.warn(`[mlx] skip ${full}: ${err.message}`);
+            continue;
+        }
+        if (NON_GENERATIVE.has(modelType))
+            continue;
+        const preset = LAUNCH_PRESETS[modelType];
+        if (!preset) {
+            if (debug)
+                console.warn(`[mlx] skip ${full}: no LAUNCH_PRESETS entry for ${modelType}`);
+            continue;
+        }
+        out.push({ name: basename(full), path: full, modelType, preset });
+    }
+    out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return out;
+}

package/dist/host/env-policy.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Engine tuning that is LAUNCHER POLICY, not an engine default.
+ *
+ * The native engine reads these knobs from the process environment through a
+ * `OnceLock`: the FIRST read latches the value for the life of the process, so
+ * every variable here must be in place before any model is loaded and must
+ * never be mutated afterwards. That one-shot latch is why the policy is a
+ * plain data object rather than something a caller can toggle at runtime.
+ *
+ * Two application shapes, deliberately different:
+ *
+ *   - In-process host (`mlx serve`, `mlx launch claude`): call
+ *     {@link applyEnginePolicy} to write `process.env` BEFORE the first load.
+ *     A value the user already set in their shell always wins — this is a
+ *     default, not an override.
+ *   - Out-of-process host (Electron `utilityProcess.fork`): pass
+ *     {@link engineEnvFor} into `fork({ env })` and never touch
+ *     `process.env` in the child. The returned map is unconditional: it
+ *     describes the child's starting environment, and the parent is expected
+ *     to spread the user's own env under it if it wants shell values to win.
+ *
+ * Keeping the two apart matters. `MLX_PAGED_PREFILL_CHUNK_SIZE` reads as
+ * `0` ("no chunking") in Rust when unset; 2048 is the value
+ * `mlx launch claude` has historically applied to bound the cold-prefill
+ * memory peak, and baking it into the engine would silently change every
+ * other embedder's behaviour.
+ */
+/** Env var names this module owns. Exported so tests can assert the exact set. */
+export declare const ENGINE_POLICY_ENV_VARS: readonly ['MLX_PAGED_PREFILL_CHUNK_SIZE'];
+export interface EnginePolicy {
+    /**
+     * `MLX_PAGED_PREFILL_CHUNK_SIZE` — tokens per paged-prefill chunk.
+     * `0` disables chunking (the Rust default when the var is unset).
+     */
+    pagedPrefillChunkSize?: number;
+}
+/**
+ * The policy `mlx launch claude` has applied since the flag existed, and the
+ * one `mlx serve` and the desktop sidecar inherit.
+ *
+ * 2048 matches the mlx-lm / mlx-vlm default and reduces per-chunk overhead
+ * versus the older 1024 for long Qwen dense contexts.
+ */
+export declare const LAUNCHER_ENGINE_POLICY: EnginePolicy;
+/**
+ * Render a policy as the environment map a forked child should start with.
+ *
+ * Unconditional by construction: there is no "already set" to respect in a
+ * child that does not exist yet.
+ */
+export declare function engineEnvFor(policy: EnginePolicy): Record<string, string>;
+/**
+ * Apply a policy to an in-process environment as a DEFAULT.
+ *
+ * Only writes vars that are currently unset — matching the historical
+ * `if (process.env.X == null)` guard, so an explicit `X=` (empty string) in
+ * the user's shell is treated as "the user has an opinion" and left alone.
+ *
+ * Returns the names actually written, so a caller can log or assert on them.
+ */
+export declare function applyEnginePolicy(policy: EnginePolicy, env?: NodeJS.ProcessEnv): string[];
+//# sourceMappingURL=env-policy.d.ts.map

package/dist/host/env-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-policy.d.ts","sourceRoot":"","sources":["../../src/host/env-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,YAAI,8BAA8B,CAAU,CAAC;AAEhF,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,YAA6D,CAAC;AAEnG;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,EAAE,CAStG"}

package/dist/host/env-policy.js

@@ -0,0 +1,69 @@
+/**
+ * Engine tuning that is LAUNCHER POLICY, not an engine default.
+ *
+ * The native engine reads these knobs from the process environment through a
+ * `OnceLock`: the FIRST read latches the value for the life of the process, so
+ * every variable here must be in place before any model is loaded and must
+ * never be mutated afterwards. That one-shot latch is why the policy is a
+ * plain data object rather than something a caller can toggle at runtime.
+ *
+ * Two application shapes, deliberately different:
+ *
+ *   - In-process host (`mlx serve`, `mlx launch claude`): call
+ *     {@link applyEnginePolicy} to write `process.env` BEFORE the first load.
+ *     A value the user already set in their shell always wins — this is a
+ *     default, not an override.
+ *   - Out-of-process host (Electron `utilityProcess.fork`): pass
+ *     {@link engineEnvFor} into `fork({ env })` and never touch
+ *     `process.env` in the child. The returned map is unconditional: it
+ *     describes the child's starting environment, and the parent is expected
+ *     to spread the user's own env under it if it wants shell values to win.
+ *
+ * Keeping the two apart matters. `MLX_PAGED_PREFILL_CHUNK_SIZE` reads as
+ * `0` ("no chunking") in Rust when unset; 2048 is the value
+ * `mlx launch claude` has historically applied to bound the cold-prefill
+ * memory peak, and baking it into the engine would silently change every
+ * other embedder's behaviour.
+ */
+/** Env var names this module owns. Exported so tests can assert the exact set. */
+export const ENGINE_POLICY_ENV_VARS = ['MLX_PAGED_PREFILL_CHUNK_SIZE'];
+/**
+ * The policy `mlx launch claude` has applied since the flag existed, and the
+ * one `mlx serve` and the desktop sidecar inherit.
+ *
+ * 2048 matches the mlx-lm / mlx-vlm default and reduces per-chunk overhead
+ * versus the older 1024 for long Qwen dense contexts.
+ */
+export const LAUNCHER_ENGINE_POLICY = Object.freeze({ pagedPrefillChunkSize: 2048 });
+/**
+ * Render a policy as the environment map a forked child should start with.
+ *
+ * Unconditional by construction: there is no "already set" to respect in a
+ * child that does not exist yet.
+ */
+export function engineEnvFor(policy) {
+    const env = {};
+    if (policy.pagedPrefillChunkSize !== undefined) {
+        env.MLX_PAGED_PREFILL_CHUNK_SIZE = String(policy.pagedPrefillChunkSize);
+    }
+    return env;
+}
+/**
+ * Apply a policy to an in-process environment as a DEFAULT.
+ *
+ * Only writes vars that are currently unset — matching the historical
+ * `if (process.env.X == null)` guard, so an explicit `X=` (empty string) in
+ * the user's shell is treated as "the user has an opinion" and left alone.
+ *
+ * Returns the names actually written, so a caller can log or assert on them.
+ */
+export function applyEnginePolicy(policy, env = process.env) {
+    const applied = [];
+    for (const [name, value] of Object.entries(engineEnvFor(policy))) {
+        if (env[name] == null) {
+            env[name] = value;
+            applied.push(name);
+        }
+    }
+    return applied;
+}

package/dist/host/index.d.ts

@@ -0,0 +1,202 @@
+/**
+ * `@mlx-node/server/host` — the reusable inference-host bootstrap.
+ *
+ * Everything a process needs to go from "a directory of downloaded models" to
+ * "a listening Anthropic/OpenAI-compatible endpoint with one resident model
+ * and a working `/model` swap", with none of the opinions about WHO supervises
+ * the process.
+ *
+ * That last part is why this is a module rather than a CLI flag. The two known
+ * front-ends invert the supervision relationship:
+ *
+ *   - `mlx launch claude` starts the host, then spawns and supervises a child
+ *     (`claude`), and exits when the child does.
+ *   - The desktop app's Electron `utilityProcess` IS the child; the host is
+ *     supervised, gets told when to shut down, and may be SIGKILLed.
+ *
+ * `mlx serve` is the third, degenerate case — nothing above, nothing below —
+ * and doubles as the terminal-visible reproduction of the sidecar when the
+ * utilityProcess wedges.
+ *
+ * A subpath export rather than part of `@mlx-node/server`'s main entry, so
+ * importing the plain HTTP handler does not drag in `@mlx-node/lm` and model
+ * loading.
+ *
+ * ## Ownership
+ *
+ * The returned host owns, and disposes on {@link InferenceHost.close}:
+ *   1. the HTTP server,
+ *   2. the verbose request logger (when `logDir` is set),
+ *   3. the `PagedConfigOverrideManager`'s temp root.
+ *
+ * The server goes first because the logger records a request from that
+ * request's own `finish`/`close` handler. Ending the log streams while a
+ * request is still draining loses exactly the completion lines a verbose
+ * shutdown exists to capture. The temp root goes last because a
+ * still-draining request may still be reading a cloned config. Each step is
+ * independently guarded — one failing disposer must not strand the ones
+ * after it.
+ */
+import type { Server } from 'node:http';
+import { type LoadableModel } from '@mlx-node/lm';
+import type { ServerHealth } from '../health.js';
+import { type CloseOptions, type ServerInstance } from '../server.js';
+import { type DiscoveredModel } from './discover.js';
+import { type EnginePolicy } from './env-policy.js';
+import { type Logger } from './logger.js';
+/** Families `mlx launch claude` has historically forced onto the paged path. */
+export declare const DEFAULT_PAGED_MODEL_TYPES: readonly ['qwen3_5', 'qwen3_5_moe'];
+/** Thrown when `modelsDir` holds nothing servable. Carries the dir for the caller's message. */
+export declare class NoModelsDiscoveredError extends Error {
+    readonly modelsDir: string;
+    constructor(modelsDir: string);
+}
+/**
+ * Thrown when a bind reachable from the network was asked for with no shared
+ * secret to gate it.
+ *
+ * There is no safe way to serve that: every route but the `/health` liveness
+ * carve-out runs inference, so an unauthenticated LAN-reachable bind hands
+ * anyone who can route to this machine the GPU, the RAM, and the list of
+ * models on disk. Failing at startup is the only outcome the operator can act
+ * on — serving-with-a-warning is a warning nobody reads scrolling past a
+ * model load.
+ */
+export declare class InsecureBindError extends Error {
+    readonly host: string;
+    constructor(host: string);
+}
+/** Thrown when a requested model name is not among the discovered ones. */
+export declare class ModelNotFoundError extends Error {
+    readonly requested: string;
+    readonly modelsDir: string;
+    readonly available: string[];
+    constructor(requested: string, modelsDir: string, available: string[]);
+}
+/** Thrown when a model load is requested after host shutdown reaches its admission boundary. */
+export declare class InferenceHostClosedError extends Error {
+    constructor();
+}
+export interface InferenceHostOptions {
+    /**
+     * Port to bind. Omitted ⇒ a free port is picked up-front (so the URL is
+     * known before the server starts, which `mlx launch claude` needs in order
+     * to bake `ANTHROPIC_BASE_URL` into the child's env). `0` binds an
+     * ephemeral port and the real one is read back off the socket.
+     */
+    port?: number;
+    /**
+     * Host to bind. Default `127.0.0.1`.
+     *
+     * A non-loopback value (including the wildcards `0.0.0.0` / `::`) requires
+     * an auth token — from {@link InferenceHostOptions.authToken} or
+     * `MLX_SERVER_AUTH_TOKEN` — or the call throws {@link InsecureBindError}
+     * instead of listening.
+     */
+    host?: string;
+    /** Model discovery root. Default: {@link resolveModelsDir}'s resolution order. */
+    modelsDir?: string;
+    /**
+     * Which discovered model is the bound/default one. Precedence, highest
+     * first: this option, `ANTHROPIC_MODEL`, `discovered[0]` (alphabetical).
+     * A name that matches nothing discovered throws {@link ModelNotFoundError}
+     * rather than silently falling back.
+     */
+    model?: string;
+    /** Shared secret for every route except `/health`. See `ServerConfig.authToken`. */
+    authToken?: string;
+    /** When set, every HTTP turn is captured under this directory. */
+    logDir?: string;
+    /**
+     * Engine env policy to apply to `process.env` BEFORE anything can load a
+     * model. Omitted ⇒ nothing is written and the engine's own defaults stand.
+     * Out-of-process hosts must pass `engineEnvFor(policy)` to `fork({ env })`
+     * instead and leave this unset — the vars latch via `OnceLock` on first
+     * read, so mutating them in the child is too late.
+     */
+    enginePolicy?: EnginePolicy;
+    /** Model types forced onto the block-paged KV cache. Default {@link DEFAULT_PAGED_MODEL_TYPES}. */
+    pagedModelTypes?: readonly string[];
+    /** Path to the SQLite response store. See `ServerConfig.storePath`. */
+    storePath?: string;
+    /** Disable response persistence entirely. See `ServerConfig.disableStore`. */
+    disableStore?: boolean;
+    /**
+     * Remove temp roots left behind by hosts that were killed without running
+     * `close()`. Default `true`; a supervisor that runs several hosts under one
+     * pid namespace and wants to control the timing can turn it off and call
+     * {@link sweepOrphanHostTempRoots} itself.
+     */
+    sweepOrphanTempRoots?: boolean;
+    /** Test seam: replaces the native model loader. */
+    loadModel?: (path: string) => Promise<LoadableModel>;
+    /** Test seam: replaces the verbose request logger. */
+    attachLogger?: (server: Server, logDir: string) => Logger;
+}
+export interface InferenceHost {
+    /** Connectable base URL, e.g. `http://127.0.0.1:51234`. */
+    url: string;
+    /** The port actually bound (resolved, never `0`). */
+    port: number;
+    /** The host actually bound — the requested value, not the advertised one. */
+    host: string;
+    /** The resolved model discovery root. */
+    modelsDir: string;
+    /** Everything discovered under `modelsDir`, alphabetical. */
+    models: DiscoveredModel[];
+    /** Name of the default/bound model. Always a member of {@link models}. */
+    boundModel: string;
+    /** Verbose log directory, or `null` when logging is off. */
+    logDir: string | null;
+    /** Escape hatch for callers that need the registry, store, or raw `http.Server`. */
+    server: ServerInstance;
+    /** Current readiness snapshot — the same body `GET /health` returns. */
+    health(): ServerHealth;
+    /**
+     * Make `name` the resident model, out of band (no HTTP request needed).
+     *
+     * Runs under the SAME brackets `ServerInstance.loadModel` uses — drains
+     * suspended OUTSIDE the coordinator's exclusive writer slot — so it cannot
+     * race the process-wide Metal allocator against in-flight inference, and
+     * `/health` reports `loading` plus a `lastLoad` record labelled with `name`.
+     *
+     * It deliberately does NOT call `ServerInstance.loadModel` itself. That
+     * helper only ever registers, never unregisters, so calling it per swap
+     * would accumulate every model the user has ever picked in memory. The
+     * single-resident swap controller is the thing that makes a swap a swap;
+     * this method just wraps it in the right brackets.
+     *
+     * Rejects with {@link ModelNotFoundError} for an unknown name — the swap
+     * controller would otherwise treat it as an alias for the current resident,
+     * which is right for Claude Code's hardcoded `claude-haiku-*` but wrong for
+     * a supervisor that asked for a specific model.
+     *
+     * Calls admitted before {@link close} begins are allowed to finish. Calls
+     * made after shutdown begins reject with {@link InferenceHostClosedError}.
+     */
+    loadModel(name: string): Promise<void>;
+    /**
+     * Stop accepting new HTTP and out-of-band load work, wait for every
+     * out-of-band load already admitted, then dispose the logger and temp root.
+     * Idempotent and memoized; disposal steps are individually guarded so one
+     * failure cannot strand the remaining steps.
+     */
+    close(opts?: CloseOptions): Promise<void>;
+}
+/**
+ * Start a local inference host.
+ *
+ * Throws {@link NoModelsDiscoveredError} / {@link ModelNotFoundError} /
+ * {@link InsecureBindError} rather than exiting — a library cannot know
+ * whether its caller is a CLI, a test, or an Electron main process. Front-ends
+ * render those into their own messages.
+ */
+export declare function createInferenceHost(opts?: InferenceHostOptions): Promise<InferenceHost>;
+export { discoverModels, type DiscoveredModel } from './discover.js';
+export { applyEnginePolicy, engineEnvFor, ENGINE_POLICY_ENV_VARS, LAUNCHER_ENGINE_POLICY, type EnginePolicy, } from './env-policy.js';
+export { attachLogger, resolveLogDir, type Logger } from './logger.js';
+export { bracketHost, hostUrl, isLoopbackBindHost, pickFreePort } from './net.js';
+export { resolveMlxNodeHome, resolveModelsDir } from './paths.js';
+export { makeSwapController, type SwapController } from './swap.js';
+export { hostTempDirPrefix, isProcessAlive, sweepOrphanHostTempRoots, HOST_TEMP_DIR_STEM, type SweepOrphanTempRootsOptions, } from './temp-root.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/host/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/host/index.ts"],"names":[],"mappings":"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"}