@aryacode/dsh-local-llm 0.0.0-stage → 0.8.2

package/lib/index.d.ts

@@ -0,0 +1,2411 @@
+import { networkInterfaces } from "node:os";
+import { IncomingMessage } from "node:http";
+import si from "systeminformation";
+//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/types/misc.d.ts
+/** String/symbol keyed dictionary type. */
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
+/** Wrap a value in `Promise`, preserving the resolved type of existing promises. */
+type Promisify<T> = Promise<T extends Promise<infer S> ? S : T>;
+/** Accept a value or promise unless the value type is already promise-like. */
+type Awaitable<T> = [T] extends [Promise<unknown>] ? T : T | Promise<T>;
+//#endregion
+//#region node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/utils.d.ts
+/** Ordered collection of disposable values with O(1) deletion by value. */
+declare class DisposableList<T extends WeakKey> {
+  private sn;
+  private map;
+  private weak;
+  get length(): number;
+  push(value: T): () => boolean;
+  delete(value: T): boolean;
+  clear(): T[];
+  [Symbol.iterator](): MapIterator<T>;
+}
+/** Shared symbols used to avoid public property-name collisions. */
+declare const symbols: {
+  shadow: symbol;
+  receiver: symbol;
+  original: symbol;
+  metadata: symbol;
+  initHooks: symbol;
+  checkProto: symbol;
+  effect: typeof Context.effect;
+  filter: typeof Context.filter;
+  isolate: typeof Context.isolate;
+  intercept: typeof Context.intercept;
+  init: typeof Service.init;
+  check: typeof Service.check;
+  config: typeof Service.config;
+  invoke: typeof Service.invoke;
+  extend: typeof Service.extend;
+  tracker: typeof Service.tracker;
+  resolveConfig: typeof Service.resolveConfig;
+};
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/registry.d.ts
+/**
+ * Service dependency declaration accepted by plugins and the `@Inject`
+ * decorator.
+ *
+ * Array form requests services without intercept config. Object form maps each
+ * service name to optional intercept config for the plugin context.
+ */
+type Inject<M = Dict> = (keyof M)[] | { [K in keyof M]?: M[K]; };
+/** Context keys that correspond to services with typed intercept config. */
+type InjectKey = keyof { [K in keyof Context & string as Context[K] extends {
+  [symbols.config]: any;
+} ? K : never]: any; };
+/**
+ * Decorator for declaring service dependencies on classes or class methods.
+ *
+ * On classes it contributes to the plugin's static `inject` map. On methods it
+ * delays the method call until the declared services are available.
+ */
+/**
+ * @param name — the required service name.
+ * @param config — optional intercept config applied for that service.
+ * @returns the class or method decorator.
+ */
+declare function Inject<K extends InjectKey>(name: K, config?: Context[K] extends {
+  [symbols.config]: infer T;
+} ? T : never): (value: any, decorator: ClassDecoratorContext<any> | ClassMethodDecoratorContext<any>) => void;
+/** Utilities for normalizing plugin dependency declarations. */
+declare namespace Inject {
+  /**
+   * Convert array/object/class-inherited inject metadata into a plain map.
+   *
+   * @param inject — the declaration to normalize; `null`/`undefined` add nothing.
+   * @param result — the map to fill (service name → intercept config or `null`).
+   * @returns `result`.
+   */
+  function resolve(inject: Inject | null | undefined, result?: Dict): Dict;
+}
+/** Supported plugin entrypoint shapes. */
+type Plugin<T = any> = Plugin.Function<T> | Plugin.Constructor<T> | Plugin.Object<T>;
+/** Types associated with plugin entrypoints and runtime records. */
+declare namespace Plugin {
+  /** Shared metadata understood by the plugin registry and related tooling. */
+  interface Base<T = any> {
+    /** Display name used for fiber diagnostics and logger names. */
+    name?: string;
+    /** Standard-schema validator applied to config before the plugin starts. */
+    Config?: StandardSchemaV1<any, T>;
+    /** Services the plugin requires; it only loads while all are available. */
+    inject?: Inject;
+    /** Service name(s) the plugin provides (read by `Service` and by loaders). */
+    provide?: string | string[];
+    /** Service names whose intercept config the plugin declares it consumes. */
+    intercept?: Dict<boolean>;
+  }
+  interface Transform<S, T> {
+    /** Marks the transform object as a schema/config transform. */
+    schema?: true;
+    /** Convert user-facing config to runtime config. */
+    Config: (config: S) => T;
+  }
+  /** Function plugin called with `(ctx, config)`. */
+  interface Function<T = any> extends Base<T> {
+    (ctx: Context, config: T): any;
+  }
+  /** Class plugin constructed with `(ctx, config)`. */
+  interface Constructor<T = any> extends Base<T> {
+    new (ctx: Context, config: T): any;
+  }
+  /** Object plugin with an `apply(ctx, config)` method. */
+  interface Object<T = any> extends Base<T> {
+    apply(ctx: Context, config: T): any;
+  }
+  /** Mutable registry record shared by all fibers of one plugin callback. */
+  interface Runtime {
+    /** Display name copied from the first registered plugin shape. */
+    name?: string;
+    /** Every live fiber of this plugin (one per `ctx.plugin()` call). */
+    fibers: DisposableList<Fiber>;
+    /** The executable entrypoint all fibers share (registry identity key). */
+    callback: globalThis.Function;
+    /** Standard-schema validator applied to each fiber's config. */
+    Config?: StandardSchemaV1;
+  }
+}
+type Spread<T> = undefined extends T ? [config?: T] : [config: T];
+type GetPluginParameters<P> = P extends ((ctx: Context, ...args: infer R) => any) ? R : P extends (new (ctx: Context, ...args: infer R) => any) ? R : P extends {
+  apply(ctx: Context, ...args: infer R): any;
+} ? R : never;
+type GetPluginConfig<P> = P extends Plugin.Transform<infer S, any> ? S : GetPluginParameters<P>[0];
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Run a callback once the requested services are available.
+     *
+     * Shorthand for `ctx.plugin({ inject, apply: callback })`: the callback
+     * is unloaded and re-run whenever a required service changes.
+     *
+     * @param deps — required services, as an array or a name → config map.
+     * @param callback — plugin body called with `(ctx, config)`.
+     * @returns the fiber; awaiting it settles once loading finished.
+     */
+    inject(deps: Inject, callback: Plugin.Function<void>): Fiber & PromiseLike<Fiber>;
+    /**
+     * Load a plugin in the current context.
+     *
+     * @param plugin — a function, class, or `{ apply }` object plugin.
+     * @param args — the plugin config, validated against its `Config` schema.
+     * @returns the fiber; awaiting it settles once loading finished
+     * (rejecting on config or startup errors).
+     */
+    plugin<P extends Plugin>(plugin: P, ...args: Spread<GetPluginConfig<P>>): Fiber & PromiseLike<Fiber>;
+  }
+}
+/**
+ * Plugin registry installed as `ctx.registry` and mixed into every context.
+ *
+ * It normalizes plugin shapes, tracks plugin runtimes, starts fibers, and
+ * exposes map-like inspection over active plugin callbacks.
+ */
+declare class RegistryService {
+  ctx: Context;
+  private _counter;
+  private _internal;
+  constructor(ctx: Context);
+  /** Allocate the next fiber uid (increments on every read). */
+  get counter(): number;
+  /** Number of registered plugin runtimes. */
+  get size(): number;
+  /**
+   * Resolve a supported plugin shape to its executable callback.
+   *
+   * @param plugin — a function, class, or `{ apply }` object plugin.
+   * @returns the callback identifying the plugin, or `undefined` if invalid.
+   */
+  resolve(plugin: Plugin): Function | undefined;
+  /**
+   * Look up the runtime record for a plugin.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns the runtime, or `undefined` when the plugin is not registered.
+   */
+  get(plugin: Plugin): Plugin.Runtime | undefined;
+  /**
+   * Check whether a plugin has a registered runtime.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns `true` when at least one fiber of the plugin exists.
+   */
+  has(plugin: Plugin): boolean;
+  /**
+   * Dispose every running fiber for a plugin and remove its runtime record.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns the removed runtime, or `undefined` when none was registered.
+   */
+  delete(plugin: Plugin): Plugin.Runtime | undefined;
+  /** Iterate the registered plugin callbacks. */
+  keys(): MapIterator<Function>;
+  /** Iterate the registered plugin runtimes. */
+  values(): MapIterator<Plugin.Runtime>;
+  /** Iterate `[callback, runtime]` pairs. */
+  entries(): MapIterator<[Function, Plugin.Runtime]>;
+  /**
+   * Visit every registered runtime.
+   *
+   * @param callback — receives each runtime and its identifying callback.
+   */
+  forEach(callback: (value: Plugin.Runtime, key: Function) => void): void;
+  /**
+   * Start a callback once the requested dependencies are available.
+   *
+   * @param inject — required services, as an array or a name → config map.
+   * @param callback — plugin body called with `(ctx, config)`.
+   * @returns the fiber; awaiting it settles once loading finished.
+   */
+  inject(inject: Inject, callback: Plugin.Function<void>): Fiber & PromiseLike<Fiber>;
+  /**
+   * Start a plugin in the current context and return its fiber.
+   *
+   * Creates (or reuses) the plugin's runtime record, then starts a new fiber
+   * under the current context. Throws if `plugin` is not a supported shape or
+   * if the current fiber is already disposed.
+   *
+   * @param plugin — a function, class, or `{ apply }` object plugin.
+   * @param config — the plugin config, validated against its `Config` schema.
+   * @param getOuterStack — captures the caller stack for effect diagnostics.
+   * @returns the fiber; awaiting it settles once loading finished.
+   */
+  plugin(plugin: Plugin, config?: any, getOuterStack?: () => string[]): Fiber & PromiseLike<Fiber>;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/reflect.d.ts
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Read a service from the store without the inject requirement.
+     *
+     * @param name — the service name.
+     * @param strict — when `true` (default), only return implementations
+     * whose providing fiber is currently active.
+     * @returns the service value, or `undefined` when not (yet) provided.
+     */
+    get<K extends string & keyof this>(name: K, strict?: boolean): undefined | this[K];
+    /** Same as above for service names outside the typed `Context` surface. */
+    get(name: string, strict?: boolean): any;
+    /**
+     * Overwrite a provided service's value.
+     *
+     * Only the fiber that provided the service may set it; setting an
+     * unprovided name throws.
+     *
+     * @param name — the service name.
+     * @param value — the new service value.
+     */
+    set<K extends string & keyof this>(name: K, value: undefined | this[K]): void;
+    /** Same as above for service names outside the typed `Context` surface. */
+    set(name: string, value: any): void;
+    /**
+     * Register a service implementation owned by the current fiber.
+     *
+     * The service becomes visible to dependents in the same isolation scope
+     * once the fiber is active; it is unregistered (waking dependents) when
+     * the returned disposer runs or the fiber unloads. Throws if the name is
+     * already provided in this scope or declared as an accessor.
+     *
+     * @param name — the service name.
+     * @param value — the service value.
+     * @returns a disposer that unregisters the service.
+     */
+    provide<K extends string & keyof this>(name: K, value: undefined | this[K]): () => void;
+    /** Same as above for service names outside the typed `Context` surface. */
+    provide(name: string, value?: any): () => void;
+    /**
+     * Define a computed context property backed by get/set hooks.
+     *
+     * The accessor is removed when the current fiber unloads. Throws if the
+     * name is already declared.
+     *
+     * @param name — the context property name.
+     * @param options — the `get` hook and optional `set` hook.
+     */
+    accessor(name: string, options: Omit<Property.Accessor, 'type'>): void;
+    /**
+     * Expose selected members of a service directly on `ctx`.
+     *
+     * Each mixed-in key becomes an accessor that forwards to the service
+     * (binding methods to it), so e.g. `ctx.on` forwards to `ctx.events.on`.
+     * Mixins are removed when the current fiber unloads.
+     *
+     * @param name — the context property holding the source service.
+     * @param mixins — keys to forward, or a source-key → ctx-key map.
+     */
+    mixin<K extends string & keyof this>(name: K, mixins: (keyof this & keyof this[K])[] | Dict<string>): void;
+    /** Same as above with a source object instead of a context property name. */
+    mixin<T extends {}>(source: T, mixins: (keyof this & keyof T)[] | Dict<string>): void;
+  }
+}
+/** Context property definition known by the reflection service. */
+type Property = Property.Service | Property.Accessor;
+/** Property definition variants understood by `ReflectService`. */
+declare namespace Property {
+  /** Service property backed by a provided implementation. */
+  interface Service {
+    /** Discriminator. */
+    type: 'service';
+  }
+  /** Computed context property backed by custom get/set hooks. */
+  interface Accessor {
+    /** Discriminator. */
+    type: 'accessor';
+    /** Compute the property value; `error` carries the caller stack for diagnostics. */
+    get: (this: Context, receiver: any, error: Error) => any;
+    /** Optional setter; return `false` to reject the write. */
+    set?: (this: Context, value: any, receiver: any, error: Error) => boolean;
+  }
+}
+/** Concrete service implementation record stored in the root reflect service. */
+interface Impl {
+  /** The service name. */
+  name: string;
+  /** The fiber that provided the service (owns its lifetime). */
+  fiber: Fiber;
+  /** The current service value. */
+  value?: any;
+  /** Optional availability predicate consulted before dependents may load. */
+  check?: () => boolean;
+}
+/**
+ * Reflection and service-resolution layer installed as `ctx.reflect`.
+ *
+ * This service powers the context proxy, service registration, accessors, and
+ * the mixins that expose core service methods directly on `ctx`.
+ */
+declare class ReflectService {
+  ctx: Context;
+  /** Proxy traps implementing service resolution for every context object. */
+  static handler: ProxyHandler<Context>;
+  /** Service implementations, keyed by isolation label. */
+  store: Dict<Impl, symbol>;
+  /** Declared context properties (services and accessors), by name. */
+  props: Dict<Property>;
+  constructor(ctx: Context);
+  /**
+   * Read a service from the store without the inject requirement.
+   *
+   * @param name — the service name.
+   * @param strict — when `true`, only return implementations whose providing
+   * fiber is currently active.
+   * @returns the service value, or `undefined` when not (yet) provided.
+   */
+  get(name: string, strict?: boolean): any;
+  _getImpl(name: string, strict?: boolean): Impl | undefined;
+  /**
+   * Overwrite a provided service's value.
+   *
+   * @param name — the service name.
+   * @param value — the new service value.
+   * @param error — carrier for the caller stack in diagnostics.
+   * @returns `true` on success.
+   * @throws when `name` was never provided, or was provided by another fiber.
+   */
+  set(name: string, value: any, error?: Error): boolean;
+  /**
+   * Register a service implementation owned by the current fiber.
+   *
+   * See the `ctx.provide()` overload above for the full contract.
+   *
+   * @param name — the service name.
+   * @param value — the service value.
+   * @param check — optional availability predicate for dependents.
+   * @returns a disposer that unregisters the service.
+   */
+  provide(name: string, value?: any, check?: () => boolean): Disposable<Promise<void>>;
+  /**
+   * Re-evaluate every fiber that requires one of the given services.
+   *
+   * @param names — the service names that changed.
+   * @param filter — restricts notification to matching isolation scopes.
+   * @returns the fibers whose dependency state was refreshed.
+   */
+  notify(names: string[], filter?: (ctx: Context, name: string) => boolean): Fiber[];
+  /**
+   * Define a computed context property backed by get/set hooks.
+   *
+   * @param name — the context property name.
+   * @param options — the `get` hook and optional `set` hook.
+   * @returns a disposer that removes the accessor.
+   */
+  accessor(name: string, options: Omit<Property.Accessor, 'type'>): Disposable<Promise<void>>;
+  /**
+   * Expose selected members of a service directly on `ctx`.
+   *
+   * See the `ctx.mixin()` overload above for the full contract.
+   *
+   * @param source — a context property name or a source object.
+   * @param mixins — keys to forward, or a source-key → ctx-key map.
+   * @returns a disposer that removes all created accessors.
+   */
+  mixin(source: any, mixins: string[] | Dict<string>): Disposable<Promise<void>>;
+  /**
+   * Attach this context's tracing wrapper to a value.
+   *
+   * @param value — the value to wrap.
+   * @returns the traceable wrapper (or the value itself when not applicable).
+   */
+  trace<T>(value: T): T;
+  /**
+   * Wrap a callback so calls trace `this` and arguments to this context.
+   *
+   * @param callback — the function to wrap.
+   * @returns a proxy delegating to `callback` with traced values.
+   */
+  bind<T extends Function>(callback: T): T;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/fiber.d.ts
+declare module './context.ts' {
+  interface Context extends Pick<Fiber, 'effect'> {
+    /** The fiber (plugin runtime instance) that owns this context. */
+    fiber: Fiber;
+  }
+}
+interface AsyncDisposable<T extends Awaitable<void> = Awaitable<void>> extends PromiseLike<() => T> {
+  (): T;
+}
+/**
+ * Function returned by an effect to release resources during disposal.
+ *
+ * Disposers run in reverse registration order when the owning fiber unloads;
+ * they may be async, in which case unloading awaits them.
+ */
+type Disposable<T = any> = () => T;
+/**
+ * Effect body result accepted by `ctx.effect()` and plugin startup.
+ *
+ * Either a single disposer, a promise of one, or a (possibly async) iterable
+ * yielding several — generator effects register each yielded disposer as it
+ * is produced.
+ */
+type Effect<T = any> = SyncEffect<T> | AsyncEffect<T>;
+type SyncEffect<T = any> = Disposable<T> | Iterable<Disposable<T>, void, void>;
+type AsyncEffect<T = any> = Promise<Disposable<T>> | AsyncIterable<Disposable<T>, void, void>;
+/** Tree node used to expose nested effect labels for diagnostics. */
+interface EffectMeta {
+  /** Human-readable effect label, e.g. `ctx.on("event")` or `ctx.provide("name")`. */
+  label: string;
+  /** Metadata of nested effects registered while this effect ran. */
+  children: EffectMeta[];
+}
+/**
+ * Lifecycle state for one plugin fiber.
+ *
+ * `PENDING` — waiting for required services; `LOADING` — the plugin callback
+ * is running; `ACTIVE` — loaded and providing; `FAILED` — the callback or its
+ * config threw; `UNLOADING` — disposers are running; `DISPOSED` — the fiber
+ * was removed and cannot restart.
+ */
+declare const enum FiberState {
+  PENDING = 0,
+  LOADING = 1,
+  ACTIVE = 2,
+  FAILED = 3,
+  DISPOSED = 4,
+  UNLOADING = 5
+}
+/**
+ * Runtime instance of one plugin application.
+ *
+ * A fiber tracks dependency state, validated config, lifecycle effects, and
+ * cleanup for the plugin context returned by `ctx.plugin()`.
+ */
+declare class Fiber {
+  parent: Context;
+  inject: Dict<any>;
+  runtime: Plugin.Runtime | null;
+  /** Unique id within the registry; 0 for the root fiber, `null` once disposed. */
+  uid: number | null;
+  /** The context this fiber's plugin runs in (extends the parent context). */
+  readonly ctx: Context;
+  /** The validated plugin config (updated by `update()`). */
+  config: any;
+  /** The raw plugin config, re-resolved before each activation. */
+  _config: any;
+  /** Current lifecycle state; transitions emit `internal/status`. */
+  state: FiberState;
+  /** Dispose this fiber: unload the plugin, then settle once cleanup finished. */
+  readonly dispose: () => Promise<void>;
+  /** Snapshot of required service implementations while loaded; `undefined` otherwise. */
+  store: Dict<Impl> | undefined;
+  /** The in-flight load/unload transition, if one is currently running. */
+  inertia: Promise<void> | undefined;
+  readonly _hooks: Dict<DisposableList<Function>>;
+  readonly _disposables: DisposableList<Disposable<any>>;
+  protected context: Context;
+  private _error;
+  private _runner;
+  private _store;
+  /**
+   * Create a fiber. Plugin authors normally obtain fibers from `ctx.plugin()`
+   * rather than constructing them directly.
+   *
+   * @param parent — the context the plugin was loaded from.
+   * @param config — raw config, validated against the runtime's schema.
+   * @param inject — resolved dependency map (service name → intercept config).
+   * @param runtime — the shared plugin runtime, or `null` for the root fiber.
+   * @param getOuterStack — captures the caller stack for effect diagnostics.
+   */
+  constructor(parent: Context, config: any, inject: Dict<any>, runtime: Plugin.Runtime | null, getOuterStack: () => string[]);
+  /** The plugin's display name, inherited from the nearest named ancestor, else `'root'`. */
+  get name(): string;
+  /**
+   * Throw if the fiber has already been disposed.
+   *
+   * @returns nothing when the fiber is still active.
+   * @throws {CordisError} `INACTIVE_EFFECT` when the fiber's uid has been cleared.
+   */
+  assertActive(): void;
+  private _execute;
+  /**
+   * Register a cleanup-aware effect on this fiber.
+   *
+   * `execute` runs immediately; the disposers it produces are collected and
+   * run (in reverse order) either when the returned disposer is called or
+   * when the fiber unloads, whichever comes first. Calling the disposer twice
+   * is a no-op. Throws `CordisError('INACTIVE_EFFECT')` if the fiber is
+   * already disposed, and `TypeError` if `execute` returns an invalid shape.
+   *
+   * @param execute — the effect body; see {@link Effect} for accepted shapes.
+   * @param label — effect label shown in `getEffects()` diagnostics.
+   * @returns a disposer that tears the effect down and settles once done.
+   */
+  effect(execute: () => SyncEffect, label?: string): Disposable<Promise<void>>;
+  /** Same as above for async effects; the disposer is also awaitable. */
+  effect(execute: () => Effect, label?: string): AsyncDisposable<Promise<void>>;
+  /**
+   * Return metadata for currently registered effects.
+   *
+   * @returns one {@link EffectMeta} tree per labeled live effect.
+   */
+  getEffects(): EffectMeta[];
+  private _getState;
+  private _updateState;
+  _checkImpl(name: string): boolean | undefined;
+  _refresh(): void;
+  private _setEpoch;
+  private _resolveConfig;
+  private _reload;
+  private _unload;
+  /**
+   * Wait for current lifecycle work and rethrow startup errors.
+   *
+   * @returns this fiber, once it has settled into a stable state.
+   * @throws the config-validation or plugin-startup error, if any.
+   */
+  await(): Promise<this>;
+  /**
+   * Dispose and immediately reload this plugin with its current config.
+   *
+   * @returns a promise resolving once the reload settled.
+   * @throws {CordisError} `INACTIVE_EFFECT` when the fiber is already disposed.
+   */
+  restart(): Promise<void>;
+  /**
+   * Validate and apply new config, then restart the plugin.
+   *
+   * Runs the `internal/update` waterfall first, so update hooks (and HMR)
+   * can veto or replace the restart.
+   *
+   * @param config — the new raw config; validated before anything restarts.
+   * @param noSave — hint for persistence hooks not to write the change back.
+   * @returns nothing; the restart runs behind the `internal/update` waterfall.
+   * @throws {ValidationError} when the new config fails validation.
+   */
+  update(config: any, noSave?: boolean): void;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/events.d.ts
+/** Extract the parameter tuple from a function type. */
+type Parameters<F> = F extends ((...args: infer P) => any) ? P : never;
+/** Extract the return type from a function type. */
+type ReturnType$1<F> = F extends ((...args: any) => infer R) ? R : never;
+/** Extract the explicit `this` type from a function type. */
+type ThisType<F> = F extends ((this: infer T, ...args: any) => any) ? T : never;
+/**
+ * Event dispatch strategy used by the event service.
+ *
+ * `emit` runs synchronous listeners without awaiting them, `parallel` awaits
+ * all listeners together, `serial` awaits them in order until one bails,
+ * `bail` stops on the first synchronous bail value, and `waterfall` composes
+ * listeners around a final `next` callback.
+ */
+type DispatchMode = 'emit' | 'parallel' | 'serial' | 'bail' | 'waterfall';
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Dispatch an event, running all listeners concurrently.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to every listener.
+     * @returns a promise resolving once every listener has settled.
+     */
+    parallel<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promise<void>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    parallel<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promise<void>;
+    /**
+     * Dispatch an event synchronously, ignoring listener return values.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to every listener.
+     */
+    emit<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): void;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    emit<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): void;
+    /**
+     * Dispatch an event, awaiting listeners in order until one bails.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to each listener.
+     * @returns the first bail value (non-null, non-false, non-undefined), if any.
+     */
+    serial<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType$1<Events[K]>>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    serial<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType$1<Events[K]>>;
+    /**
+     * Dispatch an event, calling listeners in order until one bails.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to each listener.
+     * @returns the first bail value (non-null, non-false, non-undefined), if any.
+     */
+    bail<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType$1<Events[K]>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    bail<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType$1<Events[K]>;
+    /**
+     * Dispatch an event whose last argument is a `next` continuation.
+     *
+     * Each listener wraps the rest of the chain: calling `next()` invokes the
+     * next listener (finally the built-in behavior); not calling it vetoes.
+     *
+     * @param name — the event name.
+     * @param args — listener arguments; the final one is the innermost `next`.
+     * @returns the outermost listener's return value.
+     */
+    waterfall<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType$1<Events[K]>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    waterfall<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType$1<Events[K]>;
+    /**
+     * Register an event listener owned by the current fiber.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    on<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+    /**
+     * Same as `on()`, but the listener disposes itself after its first call.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called at most once with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    once<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+  }
+}
+/** Options accepted by `ctx.on()` and `ctx.once()`. */
+interface EventOptions {
+  /** Add the listener before existing listeners for the same event. */
+  prepend?: boolean;
+  /** Receive the event regardless of context filter checks. */
+  global?: boolean;
+}
+/** Registered listener record stored by the event service. */
+interface Hook extends EventOptions {
+  ctx: Context;
+  callback: (...args: any[]) => any;
+}
+/**
+ * Event bus installed as `ctx.events` and mixed into every context.
+ *
+ * The service supports concurrent, synchronous, serial, bail, and waterfall
+ * dispatch and automatically disposes listeners with their owning fiber.
+ */
+declare class EventsService {
+  private ctx;
+  _hooks: Record<keyof any, Hook[]>;
+  constructor(ctx: Context);
+  /**
+   * Resolve listeners for one dispatch and apply context filtering.
+   *
+   * @param type — the dispatch mode, reported on `internal/dispatch`.
+   * @param args — the raw dispatch arguments; consumed up to the event name.
+   * @returns the matching listener callbacks, bound to the dispatch `this`.
+   */
+  dispatch(type: string, args: any[]): ((...args: any[]) => any)[];
+  /**
+   * Run listeners concurrently and wait for all of them.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns a promise resolving once every listener has settled.
+   */
+  parallel(...args: any[]): Promise<void>;
+  /**
+   * Run listeners synchronously without waiting for returned promises.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   */
+  emit(...args: any[]): void;
+  /**
+   * Run listeners in order, awaiting each, until one returns a bail value.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns the first bail value (see {@link isBailed}), if any.
+   */
+  serial(...args: any[]): Promise<any>;
+  /**
+   * Run listeners synchronously until one returns a bail value.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns the first bail value (see {@link isBailed}), if any.
+   */
+  bail(...args: any[]): any;
+  /**
+   * Compose listeners around the final `next` callback.
+   *
+   * The last dispatch argument is treated as the innermost `next`. Listeners
+   * run outermost-first; a listener that does not call `next()` vetoes the
+   * rest of the chain, including the built-in behavior.
+   *
+   * @param args — optional `this`, the event name, listener arguments, then `next`.
+   * @returns the outermost listener's return value.
+   */
+  waterfall(...args: any[]): any;
+  /**
+   * Store a listener record as an effect on the current fiber.
+   *
+   * @param label — effect label shown in fiber diagnostics.
+   * @param hooks — the listener list for one event.
+   * @param callback — the listener to store.
+   * @param options — placement and filtering options.
+   * @returns a disposer that unregisters the listener.
+   */
+  register(label: string, hooks: Hook[], callback: any, options: EventOptions): () => void;
+  /**
+   * Remove a stored listener record.
+   *
+   * @param hooks — the listener list for one event.
+   * @param callback — the listener to remove.
+   * @returns `true` if the listener was found and removed.
+   */
+  unregister(hooks: Hook[], callback: any): true | undefined;
+  /**
+   * Register an event listener owned by the current fiber.
+   *
+   * The listener is removed automatically when the fiber unloads. Throws
+   * `CordisError('INACTIVE_EFFECT')` if the fiber is already disposed.
+   *
+   * @param name — the event name to listen for.
+   * @param listener — called with the dispatch arguments.
+   * @param options — listener options; a boolean is shorthand for `prepend`.
+   * @returns a disposer removing the listener; `true` if it was still registered.
+   */
+  on(name: string | symbol, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+  /**
+   * Register an event listener that disposes itself after the first call.
+   *
+   * @param name — the event name to listen for.
+   * @param listener — called at most once with the dispatch arguments.
+   * @param options — listener options; a boolean is shorthand for `prepend`.
+   * @returns a disposer removing the listener; `true` if it was still registered.
+   */
+  once(name: string, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+}
+/**
+ * Built-in framework events used by core services and extension points.
+ *
+ * Plugin and status events track fiber lifecycle, service events observe
+ * dependency registration, update/get/set/listener events allow core services
+ * to intercept runtime operations, and `internal/dispatch` exposes event-bus
+ * diagnostics before public events are delivered.
+ */
+interface Events {
+  /** A plugin fiber was created or its uid was cleared on disposal. */
+  'internal/plugin'(fiber: Fiber): void;
+  /** A fiber changed lifecycle state; receives the fiber and its previous state. */
+  'internal/status'(fiber: Fiber, oldValue: FiberState): void;
+  /**
+   * Resolve raw plugin config after the fiber's injections become active.
+   * @param config - the raw config for this activation.
+   * @mode waterfall
+   */
+  'internal/config'(this: Fiber, config: any, next: () => any): any;
+  /** Interception hook for a service binding (no core producer). */
+  'internal/service'(this: Context, name: string, value: any): void;
+  /** Waterfall: a fiber config update is being applied; skip `next()` to veto. */
+  'internal/update'(this: Fiber, config: any, noSave: boolean, next: () => void): void;
+  /** Waterfall: a service is being read through the context proxy. */
+  'internal/get'(ctx: Context, name: string, error: Error, next: () => any): any;
+  /** Waterfall: a service is being written through the context proxy. */
+  'internal/set'(ctx: Context, name: string, value: any, error: Error, next: () => boolean): boolean;
+  /** Bail: a listener is being registered; a non-null result replaces registration. */
+  'internal/listener'(this: Context, name: string, listener: any, prepend: boolean): void;
+  /** An event is being dispatched to listeners (fired for non-internal events only). */
+  'internal/dispatch'(mode: DispatchMode, name: string, args: any[], thisArg: any): void;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/logger.d.ts
+declare module './context.ts' {
+  interface Intercept {
+    logger: LoggerService.Intercept;
+  }
+}
+/** Logger method name and severity category. */
+type LoggerType = 'error' | 'info' | 'warn' | 'debug';
+/** Callable shape for one logger severity method. */
+type LoggerMethod = (format: any, ...param: any[]) => void;
+/** Formatter used to resolve a printf-style placeholder. */
+type Formatter = (value: any, exporter: Exporter, message: Message) => any;
+/** Structured log record delivered to exporters. */
+interface Message {
+  sn: number;
+  ts: number;
+  name: string;
+  type: LoggerType;
+  level: number;
+  args: any[];
+  fiber?: WeakRef<Fiber>;
+}
+/** Sink that receives structured log messages. */
+interface Exporter {
+  colors?: number | false;
+  maxLength?: number;
+  levels?: Record<string, number>;
+  formatters?: Record<string, Formatter>;
+  export(message: Message): void;
+}
+/** Options used when creating a named logger facade. */
+interface LoggerOptions {
+  /** The logger name shown with each message. */
+  name: string;
+  /** Message fields merged into every record from this logger. */
+  meta?: Partial<Message>;
+  /** Default maximum level exported when an exporter has no own threshold. */
+  level?: number;
+}
+/** Logger facade identity, inherited message metadata, and optional minimum level. */
+interface Logger extends LoggerOptions {}
+/** Logger facade severity methods. */
+interface Logger extends Record<LoggerType, LoggerMethod> {}
+/** Logger facade for one named subsystem. */
+declare class Logger {
+  private service;
+  static color(exporter: Exporter, code: number, value: any, decoration?: string): string;
+  static code(name: string, level?: false | number): number;
+  static format(exporter: Exporter, message: Message): string;
+  constructor(options: LoggerOptions, service: LoggerService);
+  private _method;
+}
+/** Logger service configuration merged from context intercepts. */
+declare namespace LoggerService {
+  interface Intercept {
+    name?: string;
+    level?: number;
+  }
+}
+/** Callable `ctx.logger` service shape. */
+interface LoggerService extends Record<LoggerType, LoggerMethod> {
+  (name?: string): Logger;
+}
+/**
+ * Built-in logging service.
+ *
+ * Call `ctx.logger()` to create a named logger, or call `ctx.logger.info()`
+ * directly to log with the current fiber-derived name.
+ */
+declare class LoggerService {
+  bufferSize: number;
+  buffer: Message[];
+  ctx: Context;
+  _snMessage: number;
+  _snExporter: number;
+  exporters: Map<number, Exporter>;
+  constructor(ctx: Context);
+  /**
+   * Register an exporter and dispose it with the current fiber.
+   *
+   * @param exporter — the sink that receives structured log messages.
+   * @returns a disposer that removes the exporter.
+   */
+  exporter(exporter: Exporter): Disposable<Promise<void>>;
+  private _resolveConfig;
+  [symbols.invoke](name?: string): Logger;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/context.d.ts
+/**
+ * Public shape of a Cordis context.
+ *
+ * The concrete `Context` class is proxied at runtime, so this interface is
+ * augmented by core services and plugins to describe the properties that may
+ * be read from `ctx`.
+ */
+interface Context {
+  /** Isolation map: service name → scope label. Lookups for a name resolve within its label. */
+  [symbols.isolate]: Dict<symbol>;
+  /** Intercept map: service name → config merged into that service's per-plugin config. */
+  [symbols.intercept]: Dict;
+  /** The root context of the application (every child context shares it). @experimental */
+  root: this;
+  /** Base URL used to resolve relative plugin/module specifiers, if the runtime sets one. */
+  baseUrl?: string;
+  /** The event bus. Its methods are also mixed onto `ctx` (`ctx.on`, `ctx.emit`, ...). */
+  events: EventsService;
+  /** The logging service. Call `ctx.logger(name)` for a named logger. */
+  logger: LoggerService;
+  /** The reflection layer backing the context proxy (`ctx.get`, `ctx.provide`, ...). */
+  reflect: ReflectService;
+  /** The plugin registry. Its methods are mixed onto `ctx` (`ctx.plugin`, `ctx.inject`). */
+  registry: RegistryService;
+}
+/**
+ * Root and child dependency containers for Cordis plugins.
+ *
+ * A context is a proxy: normal property reads go through the service resolver,
+ * while `extend()`, `isolate()`, and `intercept()` create scoped child
+ * contexts without mutating their parent.
+ */
+declare class Context {
+  /** Symbol key under which a disposer exposes its {@link EffectMeta} diagnostics tree. */
+  static readonly effect: unique symbol;
+  /** Symbol key for a context's listener filter, consulted on every event dispatch. */
+  static readonly filter: unique symbol;
+  /** Symbol key of the isolation map (see the `Context[symbols.isolate]` property). */
+  static readonly isolate: unique symbol;
+  /** Symbol key of the intercept map (see the `Context[symbols.intercept]` property). */
+  static readonly intercept: unique symbol;
+  /**
+   * Returns true for Cordis context proxies and context prototypes.
+   *
+   * Works across realms and across multiple copies of cordis, because the
+   * brand is keyed by a global symbol rather than by `instanceof`.
+   *
+   * @param value — the value to test.
+   * @returns `true` if `value` is a Cordis context, narrowing its type.
+   */
+  static is(value: any): value is Context;
+  /** Create the root context and install the built-in services. */
+  constructor();
+  /**
+   * Create a child context with extra metadata on top of the current scope.
+   *
+   * The child prototypally inherits every property of this context; own
+   * properties of `meta` shadow the inherited ones. The parent is not mutated.
+   *
+   * @param meta — own properties (including symbol keys) to define on the child.
+   * @returns a child context inheriting from this one.
+   */
+  extend(meta?: {}): this;
+  /**
+   * Create a child context with an independent service scope for `name`.
+   *
+   * Below the returned context, reads and writes of the service `name`
+   * resolve against the new label instead of the parent's, so a different
+   * implementation can be provided without affecting the parent scope.
+   * Passing the same `label` to two `isolate()` calls joins their scopes.
+   *
+   * @param name — the service name to isolate.
+   * @param label — scope label to join; defaults to a fresh unique symbol.
+   * @returns a child context whose `name` service resolves in the new scope.
+   */
+  isolate(name: string, label?: symbol): this;
+  /**
+   * Add service-specific intercept config for plugins started below this
+   * context.
+   *
+   * Plugins loaded under the returned context see `config` merged into the
+   * service's resolved config (ancestor entries first; see
+   * `Service[symbols.resolveConfig]`). The parent context is not affected.
+   *
+   * @param name — the service name whose config to intercept.
+   * @param config — the intercept config to merge for that service.
+   * @returns a child context carrying the additional intercept entry.
+   */
+  intercept<K extends InjectKey>(name: K, config: Context[K] extends {
+    [symbols.config]: infer T;
+  } ? T : never): this;
+  intercept(name: string, config: any): this;
+}
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/cordis/lib/types/service.d.ts
+/**
+ * Base class for services that expose a named API on `ctx`.
+ *
+ * Subclasses call `super(ctx, name)` from their constructor. The service is
+ * registered immediately and is automatically removed with the owning fiber.
+ */
+declare abstract class Service<out T = never> {
+  protected ctx: Context;
+  /** Symbol key of an instance method run after construction (class plugins). */
+  static readonly init: unique symbol;
+  /** Symbol key of the availability predicate passed to `ctx.provide()`. */
+  static readonly check: unique symbol;
+  /** Symbol key of the phantom intercept-config type parameter. */
+  static readonly config: unique symbol;
+  /** Symbol key of the call body making a service callable (e.g. `ctx.logger()`). */
+  static readonly invoke: unique symbol;
+  /** Symbol key of the helper deriving an extended service instance. */
+  static readonly extend: unique symbol;
+  /** Symbol key of the tracker metadata used for context tracing. */
+  static readonly tracker: unique symbol;
+  /** Symbol key of the intercept-config resolution helper below. */
+  static readonly resolveConfig: unique symbol;
+  [symbols.config]: T;
+  /** The service name this instance is registered under. */
+  name: string;
+  /**
+   * Register this instance as `name` in the current context.
+   *
+   * Calls `ctx.reflect.provide(name, this, this[Service.check])`, so the
+   * service is unregistered automatically when the owning fiber unloads.
+   * Services with a `[Service.invoke]` body return a callable instance.
+   *
+   * @param ctx — the context to register in (stored as `this.ctx`).
+   * @param name — the service name; defaults to the static `provide` field.
+   */
+  constructor(ctx: Context, name: string);
+  protected [symbols.filter](ctx: Context): boolean;
+  protected [symbols.extend](props?: any): any;
+  /**
+   * Merge intercept config from ancestors with optional base and head values.
+   *
+   * Entries added closer to the root apply first; `base` is prepended and
+   * `head` appended. Uses `Config.merge` when the service declares one,
+   * otherwise a shallow `Object.assign`.
+   *
+   * @param base — lowest-precedence config merged before all intercepts.
+   * @param head — highest-precedence config merged after all intercepts.
+   * @returns the merged config.
+   */
+  [symbols.resolveConfig](base?: T, head?: T): T;
+  static [Symbol.hasInstance](instance: any): boolean;
+}
+//#endregion
+//#region src/strata/connection.d.ts
+/** The part of a row config this module reads. */
+interface RowConnection {
+  /** `controlToken`: what any caller not on this machine must present TO this Host. */
+  readonly controlToken?: unknown;
+  /** `connectionToken`: what THIS Host presents to the address it dials. */
+  readonly connectionToken?: unknown;
+  /** `connectionAddress`: the short form. */
+  readonly connectionAddress?: unknown;
+  /** `connection: { address, token }`: the long form. */
+  readonly connection?: unknown;
+}
+//#endregion
+//#region src/strata/pairing.d.ts
+/** One paired computer, as the engine computer stores it. */
+interface DeviceEntry {
+  /** Short opaque id, for revoking this device and for nothing else. */
+  readonly id: string;
+  /** What the pairing computer called itself when it redeemed the code. */
+  readonly label: string;
+  /** Epoch milliseconds the token was issued. */
+  readonly created: number;
+  /** SHA-256 of the token, hex. The token itself is never stored here. */
+  readonly hash: string;
+}
+/** A device as the page may see it: everything except the hash. */
+interface DeviceView {
+  readonly id: string;
+  readonly label: string;
+  readonly created: number;
+}
+/** A freshly minted device token, and the entry that verifies it. */
+interface IssuedToken {
+  /** The secret, shown to this computer once and stored only by the joining computer. */
+  readonly token: string;
+  /** What the engine computer records. */
+  readonly device: DeviceEntry;
+}
+/**
+ * The paired computers, on the engine computer.
+ *
+ * A file rather than the profile row, and this is the one place the choice
+ * differs from `connection.ts`: an inbound token is not something a user types
+ * or reviews, it is a credential this Host issued, and a profile row is read,
+ * diffed and pasted around. Only the hash is written, so the file is worth
+ * stealing only in the sense that it names machines.
+ */
+declare class DeviceTokens {
+  private readonly path;
+  private readonly now;
+  private cache;
+  /**
+   * @param path - file holding the devices.
+   * @param now - clock, injected so `created` is testable.
+   */
+  constructor(path: string, now?: () => number);
+  /**
+   * Mint a token for one computer and remember its hash.
+   * @param label - what the joining computer calls itself.
+   * @returns The token and entry, or null when the file could not be written.
+   */
+  issue(label: string): IssuedToken | null;
+  /**
+   * Verify a presented token against every stored hash.
+   * @param token - value from `Authorization: Bearer`.
+   * @returns The device it belongs to, or null.
+   */
+  verify(token: string): DeviceEntry | null;
+  /**
+   * Every paired computer, without its hash.
+   * @returns Devices, newest first.
+   */
+  list(): readonly DeviceView[];
+  /**
+   * Forget one computer.
+   * @param id - the id {@link list} reported.
+   * @returns True when something was removed and written.
+   */
+  revoke(id: string): boolean;
+  /** Read the file, treating anything unreadable as no devices. */
+  private read;
+  /** Write the file atomically, and drop the cache so the next read is this write. */
+  private write;
+}
+//#endregion
+//#region src/strata/index.d.ts
+/** Health of the engine as the panel reports it. */
+type StrataPhase = 'running' | 'starting' | 'stopped' | 'foreign' | 'stalled';
+/** The engine's own `/health` answer, narrowed to what the panel shows. */
+interface StrataHealth {
+  readonly loaded: boolean;
+  readonly model: string | null;
+  readonly maxContext: number | null;
+  readonly images: boolean;
+  readonly apiKey: boolean;
+}
+/** Machine telemetry: the GPU and system RAM the engine reports. */
+interface StrataMachine {
+  readonly gpu: {
+    readonly name: string | null;
+    /** Whether the engine reports an elastic VRAM allocation. */
+    readonly elastic: boolean | null;
+    readonly usedMib: number | null;
+    readonly totalMib: number | null;
+    readonly utilPct: number | null;
+    readonly tempC: number | null;
+    readonly powerW: number | null;
+  } | null;
+  readonly ram: {
+    readonly usedGib: number | null;
+    readonly totalGib: number | null;
+  } | null;
+}
+/** One finished request's timings, in the engine's own field names. */
+interface StrataTiming {
+  readonly promptTokens: number | null;
+  readonly generatedTokens: number | null;
+  /** Tokens reused from the prompt cache on that request. */
+  readonly cachedTokens: number | null;
+  readonly decodeTokPerSec: number | null;
+  readonly promptTokPerSec: number | null;
+  /** Wall time of that request's prefill, in ms. */
+  readonly promptMs: number | null;
+  /** Wall time of that request's decode, in ms. */
+  readonly decodeMs: number | null;
+  /** Draft tokens proposed and accepted on that request. */
+  readonly draftTokens: number | null;
+  readonly acceptedDraftTokens: number | null;
+  /** When that request finished, in the engine's own clock units. */
+  readonly at: number | null;
+}
+/** Request activity the engine counts itself, beside the log evidence. */
+interface StrataActivity {
+  readonly requests: number | null;
+  readonly inFlight: number | null;
+  /** Engine-clock timestamp of the most recent request. */
+  readonly lastRequestAt: number | null;
+  /** Concurrency the engine reports: how many requests it serves at once. */
+  readonly serving: number | null;
+  readonly requestedConcurrency: number | null;
+}
+/** What the engine log's tail says about the last few requests. */
+interface StrataLogEvidence {
+  readonly expertCacheHitPct: number | null;
+  readonly pcieRoutedPct: number | null;
+  readonly draftAcceptPct: number | null;
+  readonly lastPromptTokens: number | null;
+}
+/** Readiness of the tune flags in the engine config. */
+interface StrataTuning {
+  readonly maxContextArg: string | null;
+  readonly pcieFrac: string | null;
+  readonly specMinP: string | null;
+  readonly kvResident: string | null;
+  readonly poolWorkers: string | null;
+  /** True when both calibration flags survived the last config write. */
+  readonly calibrated: boolean;
+}
+/** Everything the panel renders in one poll. */
+interface StrataState {
+  /** What the panel shows as the engine's condition. */
+  readonly phase: StrataPhase;
+  /** Whether this Host can see a process serving Strata's port. */
+  readonly reachable: boolean;
+  /** Whether the HTTP endpoint answers, regardless of model load. */
+  readonly responding: boolean;
+  readonly health: StrataHealth | null;
+  readonly machine: StrataMachine | null;
+  readonly timing: StrataTiming | null;
+  readonly activity: StrataActivity | null;
+  readonly logEvidence: StrataLogEvidence | null;
+  /** Uptime of the engine process, from the load path that started it. */
+  readonly uptimeS: number | null;
+  /**
+   * PID of the engine process (`strata.exe`). This is the process that holds
+   * the model, the arena and the VRAM, and it is not the process this Host
+   * starts or stops.
+   */
+  readonly enginePid: number | null;
+  /**
+   * PID of the interpreter this Host started (`server.py`), which supervises the
+   * engine. Lifecycle actions act on THIS tree, so the panel names it
+   * separately rather than showing one PID for both.
+   */
+  readonly serverPid: number | null;
+  /** Resident bytes of the tracked process tree, summed over the tree. */
+  readonly rssBytes: number | null;
+  readonly port: number;
+  readonly baseUrl: string;
+  readonly modelName: string;
+  /** Engine build reported by its own status endpoint. */
+  readonly engineVersion: string | null;
+  readonly tuning: StrataTuning;
+  readonly logPath: string;
+  readonly configPath: string;
+  /** Whether this Host holds the process it would stop. */
+  readonly owned: boolean;
+  /** One line the panel shows verbatim: what happened, or why nothing did. */
+  readonly detail: string;
+  /** Identity of a process holding the port that this Host did not start. */
+  readonly foreignPid: number | null;
+  readonly checkedAt: number;
+}
+/** Outcome of one lifecycle action. */
+interface StrataActionResult {
+  readonly ok: boolean;
+  /** One line the panel shows verbatim. */
+  readonly detail: string;
+  readonly state: StrataState;
+}
+/** Raw plugin config, as the Loader hands it over. */
+interface StrataConfig {
+  /** Engine HTTP base URL, used for health and telemetry. */
+  readonly baseUrl?: string;
+  /** Environment variable holding the engine's API key, for authorized reads only. */
+  readonly apiKeyEnv?: string;
+  /** Interpreter that runs the server entry point. */
+  readonly pythonPath?: string;
+  /** Working directory the server runs from. */
+  readonly serverDirectory?: string;
+  /** Engine config file the launcher reads (args, model, api_key). */
+  readonly configPath?: string;
+  /** Engine log the panel tails. */
+  readonly logPath?: string;
+  /** Port the engine listens on. */
+  readonly port?: number;
+  /** How long a start may take before the panel calls it stalled. */
+  readonly startTimeoutMs?: number;
+  /** How long a graceful stop may take before the tree is force-killed. */
+  readonly stopTimeoutMs?: number;
+  /** Lines of engine log the panel may read. */
+  readonly logTailLines?: number;
+  /** Where this Host saves the control address its pages are told to use; defaults to the profile directory. */
+  readonly connectionPath?: string;
+  /**
+   * Where paired computers are recorded; defaults to `strata-tokens.json` beside
+   * the connection file. Only token hashes are written.
+   */
+  readonly tokensPath?: string;
+  /** Bearer token a remote caller must present; '' leaves the routes to loopback callers and paired devices. */
+  readonly controlToken?: string;
+  /** Extra origins allowed to call these routes, each an origin such as `https://host.example.ts.net`. */
+  readonly allowedOrigins?: readonly string[];
+  /**
+   * Fixed port for the paired-computer relay, or 0 to turn it off.
+   *
+   * The app's own web port is chosen afresh at every launch, so a pairing that
+   * saved that port stops working on the next restart. The relay gives those
+   * routes an address that does not change.
+   */
+  readonly pairPort?: number;
+  /** Address the relay binds; defaults to this computer's tailnet address. */
+  readonly pairHost?: string;
+}
+/** The config as this plugin uses it, with every default resolved. */
+interface ResolvedConfig {
+  readonly baseUrl: string;
+  readonly apiKeyEnv: string;
+  readonly pythonPath: string;
+  readonly serverDirectory: string;
+  readonly configPath: string;
+  readonly logPath: string;
+  readonly port: number;
+  readonly startTimeoutMs: number;
+  readonly stopTimeoutMs: number;
+  readonly logTailLines: number;
+  readonly connectionPath: string | undefined;
+  readonly tokensPath: string | undefined;
+  readonly controlToken: string;
+  readonly allowedOrigins: readonly string[];
+  readonly pairPort: number;
+  readonly pairHost: string | undefined;
+  /** The row's own fields, so the connection target can prefer them over the file. */
+  readonly rowConnection: RowConnection;
+}
+/** The tracked process table for the port this Host owns. */
+declare class StrataService {
+  readonly config: ResolvedConfig;
+  private tracked;
+  private startingSince;
+  private lastStartDetail;
+  constructor(config: ResolvedConfig);
+  /** PID of the interpreter this Host started, when it still owns it. */
+  get ownedPid(): number | null;
+  /**
+   * Whether this Host can stop what is currently running.
+   *
+   * Ownership is resolved from the LIVE PROCESS TABLE, not from memory, because
+   * memory does not survive the cases that matter: a plugin reload, a route
+   * handler in a fresh module instance, or a restart performed by anything other
+   * than this panel. Tracking only "the PID I spawned" meant a server started
+   * seconds earlier read as `foreign`, which disabled the panel's own Stop and
+   * Restart buttons on a server it had just launched — a real defect.
+   *
+   * ADOPTION IS NARROW ON PURPOSE: the candidate must be a `python.exe` whose
+   * command line names THIS config file. That is what keeps the rule safe on a
+   * machine where port 8080 is also held by `tailscaled` and where an unrelated
+   * launcher (a batch file in Explorer, or `START-HERE.bat`) may be what
+   * actually started the engine. Any other launcher for the same config file is
+   * still the same server this panel exists to manage, so it is adopted; a
+   * process for a different config is left alone.
+   */
+  get owns(): boolean;
+  /**
+   * Find the launcher for this config file and claim its tree.
+   * @returns the adopted process, or null when nothing matches.
+   */
+  private adopt;
+  /**
+   * Snapshot the engine, its telemetry and its log evidence.
+   * @returns everything one panel poll renders.
+   */
+  state(): Promise<StrataState>;
+  /** Load-path detail line: the panel shows this instead of a bare spinner. */
+  private detailOf;
+  /** Which of the five conditions the engine is in. */
+  private phaseOf;
+  /** Resident bytes across the engine plus every PID this Host started. */
+  private treeResidentBytes;
+  /** Headers for the engine's key-guarded reads.
+   *
+   * The key is looked for in the environment first, then in the engine config
+   * file's own `api_key`. The second source matters because Strata's launcher
+   * stores it there; without it the panel would lose the machine block and the
+   * per-request timings on a machine whose shell exports nothing.
+   */
+  private authHeaders;
+  /**
+   * The key the engine's own `/v1` surface demands.
+   *
+   * Read here rather than in the model library because the two sources this Host
+   * already trusts — the environment and the engine config the launcher wrote —
+   * stay in one place; a key-guarded engine would otherwise answer the model
+   * listing with 401 and look like an engine with no models.
+   * @returns The bearer key, or '' when the engine is keyless.
+   */
+  engineApiKey(): Promise<string>;
+  /** One resolution rule for every caller that needs the key. */
+  private apiKeyFrom;
+  /**
+   * Start the engine detached and record the tree this Host owns.
+   * @returns the outcome line and the state afterwards.
+   */
+  start(): Promise<StrataActionResult>;
+  /** The engine's key, from the environment or the config file's own record. */
+  private engineKey;
+  /**
+   * Stop the engine this Host started, by PID tree and never by port.
+   *
+   * A graceful path goes first when the engine holds a key: the server answers a
+   * SIGTERM by telling the engine to quit, which lets it release 37 GB of
+   * registered memory and its VRAM before the process ends. A forced kill of a
+   * model that large leaves the GPU to clean up after it, so the gentle path is
+   * worth one extra process.
+   * @returns the outcome line and the state afterwards.
+   */
+  stop(): Promise<StrataActionResult>;
+  /**
+   * Stop then start, so the config file's current args are what loads.
+   * @returns the outcome line and the state afterwards.
+   */
+  restart(): Promise<StrataActionResult>;
+  /** The engine log tail, for the panel's log view. */
+  logs(lines?: number): Promise<string>;
+}
+/** Wiring the desktop half needs from the plugin row, separate from the route policy. */
+interface StrataRouteOptions {
+  /** The paired-computer registry, when the caller already created it. */
+  readonly devices?: DeviceTokens;
+  /**
+   * Called once a pairing code was redeemed HERE, with the address and token of
+   * the computer this one now drives.
+   *
+   * Pairing and model sharing are one act from the operator's point of view —
+   * they typed one code to make the other engine usable here — so the routes
+   * report the result rather than leaving a second, separate connection to be
+   * set up by hand.
+   */
+  readonly onJoined?: ((address: string, token: string) => void) | undefined;
+  /** Called after a local lifecycle action so host model lists resolve again. */
+  readonly onChanged?: (() => void) | undefined;
+  /** Stop other local engines before this start; a rejection refuses the start. */
+  readonly beforeStart?: (() => Promise<void>) | undefined;
+}
+/**
+ * Mount the panel's routes on the harness web server.
+ *
+ * TWO GATES, and they answer different questions.
+ *
+ * WHICH CALLERS. A browser needs an answer to its preflight before it may send
+ * a custom header, so these routes answer one — but only for an origin this
+ * Host accepts: the origin the page was served from, plus whatever
+ * `allowedOrigins` names. An origin nobody named gets no CORS headers and its
+ * preflight is refused, which is what keeps an arbitrary page from reading the
+ * machine snapshot or starting a 37 GB model.
+ *
+ * WHICH REQUESTS. `x-strata-control` still marks a write, and it still cannot
+ * be set cross-origin without the preflight above — but it is a shape check,
+ * not a secret, so it is no longer the whole story. Any request that did not
+ * arrive over loopback must additionally present `controlToken` as a bearer
+ * token, constant-time compared. A Host with no token configured therefore
+ * serves loopback callers only, which is the safe default for a setting nobody
+ * has opened up yet.
+ *
+ * The two gates compose: the preflight is answered for a named origin, and the
+ * act itself needs the token. Neither alone would be enough.
+ *
+ * WHICH MACHINE. The same five routes also serve a computer that was pointed at
+ * another one: a request carrying `x-strata-target: remote` is relayed to the
+ * saved address with the saved token, server to server. That is what lets a
+ * laptop's panel drive this Host's engine — the browser stays same-origin with
+ * its own AryaAI, so no origin has to be opened up for it, and the token stays
+ * in the server half on both machines.
+ * @param ctx - host root context.
+ * @param service - the Strata service the routes act on.
+ * @param config - the resolved row config, for the caller policy and the saved target.
+ * @returns disposer for every registration.
+ */
+declare function mountRoutes(ctx: Context, service: StrataService, config: ResolvedConfig, options?: StrataRouteOptions): () => void;
+/** The handles the desktop half needs from this plugin row. */
+interface StrataHandle {
+  /** Whether a token is one this Host issued to a paired computer. */
+  verifyDevice(token: string): boolean;
+  /** Base URL of the engine's OpenAI-compatible surface, without a trailing slash. */
+  readonly baseUrl: string;
+  /** Bearer key the engine demands, or '' when it is keyless. */
+  apiKey(): Promise<string>;
+}
+/**
+ * The computer this one is pointed at, as the row or its stored file says.
+ *
+ * Startup uses this to reconnect model sharing for a pairing made before the
+ * two halves were linked, so an existing installation does not have to pair a
+ * second time.
+ * @param rawConfig - the bundle row's config, validated here rather than trusted.
+ * @returns The address and token, or null when this computer uses its own engine.
+ */
+declare function linkedTarget(rawConfig?: unknown): {
+  address: string;
+  token: string;
+} | null;
+/**
+ * Register the Strata service and its routes.
+ * @param ctx - host root context.
+ * @param rawConfig - the bundle row's config, validated here rather than trusted.
+ * @param hooks - optional link into the desktop half (model sharing).
+ */
+declare function apply$1(ctx: Context, rawConfig?: unknown, hooks?: {
+  onJoined?: (address: string, token: string) => void;
+  onChanged?: () => void;
+  beforeStart?: () => Promise<void>;
+}): StrataHandle;
+//#endregion
+//#region src/strata/relay.d.ts
+/** What a mounted relay reports back to the routes that advertise addresses. */
+interface PairRelay {
+  /** Address the relay listens on, or null while it is not listening. */
+  readonly address: {
+    host: string;
+    port: number;
+  } | null;
+  /** Close the listener; safe to call more than once. */
+  close(): void;
+}
+/**
+ * Start the relay.
+ *
+ * Binding is asynchronous: a port already in use (a second AryaAI instance on
+ * the same machine) or an address that is not up yet leaves {@link PairRelay.address}
+ * null, and the routes fall back to the app's own port exactly as before.
+ * @param options - upstream port, bind host and the fixed port.
+ * @returns the relay handle, listening or not.
+ */
+declare function startPairRelay(options: {
+  readonly upstreamPort: number;
+  readonly host: string;
+  readonly port: number;
+  readonly onError?: (reason: string) => void;
+}): PairRelay;
+//#endregion
+//#region src/library.d.ts
+type Data$4 = Record<string, any>;
+declare const LIBRARY_PROVIDER = "local-library";
+/**
+ * The per-request output default this adapter publishes for one model.
+ *
+ * An engine's *maximum* response allowance is a ceiling it enforces when a
+ * request asks for it, not something every request should ask for: this value
+ * is materialized into requests that omit an output budget, so it stays small
+ * (8K, and never more than a quarter of the model's own context window).
+ */
+declare function outputDefault(context: number, ceiling?: number): number;
+/** Where the Strata engine's own OpenAI-compatible surface answers, and how to authorize it. */
+interface StrataModelSource {
+  /** Engine base URL, without a trailing slash, e.g. `http://127.0.0.1:8080`. */
+  readonly baseUrl: string;
+  /** Bearer key the engine demands, or '' when the engine is keyless. */
+  readonly apiKey: () => Promise<string>;
+  /**
+   * Whether the engine already serves this model.
+   *
+   * A loaded model needs no change, so it must not be held behind the engine's
+   * busy flag: a flag left behind by a client that disconnected mid-stream
+   * would otherwise refuse inference the engine can serve right now.
+   */
+  readonly ready?: (model: Data$4) => Promise<boolean>;
+}
+/** The owned NInfer engine this installation can start and serve. */
+interface NInferModelSource {
+  readonly port: number;
+  readonly outputTokens: () => number;
+  readonly status: () => Promise<{
+    phase?: string;
+    healthy?: boolean;
+    modelName?: string;
+    context?: number;
+    vision?: boolean;
+  }>;
+}
+/**
+ * Build the model-library adapter.
+ *
+ * The return type is restated as `any`: the harness adapter type names a private
+ * `@deepseek-ai/dsh-llm` type that the emitted declaration could not reference
+ * without an import this plugin does not depend on (TS2742). The value is only
+ * handed to `registerAdapter`, which still checks it at the call site.
+ */
+declare function libraryAdapter(controller: Data$4, ensure: (model: Data$4) => Promise<void>, gate: Data$4, checkIdle: () => Promise<void>, attachments: Data$4 | undefined, strata?: StrataModelSource, ninfer?: NInferModelSource): any;
+//#endregion
+//#region src/hardware.d.ts
+declare function hardwareCollector(source?: typeof si): () => Promise<Record<string, unknown>>;
+//#endregion
+//#region src/ninfer.d.ts
+/** Settings supported by the tested MTP and vision profile. */
+interface NInferSettings {
+  context: number;
+  prefill: number;
+  hostKvMiB: number;
+  draftTokens: number;
+  vision: boolean;
+  /** MTP n-gram drafts: `chain` speculates from the prompt and the running reply, `off` disables them. */
+  ngram: 'off' | 'chain';
+  /** Default response allowance; the engine and the chat model share the context window. */
+  outputTokens: number;
+}
+/** Validate settings received from disk or the Control Center. */
+declare function validateNInfer(value: unknown): NInferSettings;
+/** Verify both Docker identity and the owner marker before a destructive action. */
+declare function ownsNInfer(owner: {
+  id: string;
+  name: string;
+  label: string;
+} | null, container: {
+  Id: string;
+  Name: string;
+  Config: {
+    Labels: Record<string, string>;
+  };
+} | null, name: string, label: string): boolean;
+/** A container as `docker inspect` describes it, limited to the fields identity needs. */
+interface NInferContainer {
+  Id: string;
+  Name: string;
+  Config: {
+    Image?: string;
+    Labels?: Record<string, string>;
+  };
+  Mounts?: {
+    Source: string;
+    Destination: string;
+  }[];
+  HostConfig?: {
+    PortBindings?: Record<string, {
+      HostIp?: string;
+      HostPort?: string;
+    }[]> | null;
+  } | null;
+  State: {
+    Running: boolean;
+  };
+}
+/**
+ * Whether a running container is provably this installation's engine: the same
+ * pinned image, this artifact, our port, and the label a NInfer launcher writes.
+ * Another launcher may start the engine the page will otherwise refuse to touch.
+ */
+declare function reclaimsNInfer(container: NInferContainer | null, image: string, artifact: string, port: number): boolean;
+/** Control only the saved runtime identity; leave other engines untouched. */
+declare class NInferController {
+  readonly directory: string;
+  readonly port: number;
+  readonly modelName: string;
+  private changing;
+  private readonly config;
+  constructor(config: {
+    directory: string;
+    artifact: string;
+    image: string;
+    name: string;
+    label: string;
+    port: number;
+    modelName: string;
+    defaults: NInferSettings;
+    wsl?: {
+      distribution: string;
+      binary: string;
+      libraryPath: string;
+    };
+  });
+  /** Resolve saved tuning or validated deployment defaults. */
+  settings(): NInferSettings;
+  private callWsl;
+  /** A container this Host may reclaim; a missing Docker or an unrelated one is no takeover. */
+  private external;
+  private wslStatus;
+  private docker;
+  private container;
+  private owner;
+  private complete;
+  /** Report owned process or container identity independently from API readiness. */
+  status(): Promise<{
+    context: number;
+    prefill: number;
+    hostKvMiB: number;
+    draftTokens: number;
+    vision: boolean;
+    /** MTP n-gram drafts: `chain` speculates from the prompt and the running reply, `off` disables them. */
+    ngram: "off" | "chain";
+    /** Default response allowance; the engine and the chat model share the context window. */
+    outputTokens: number;
+    phase: string;
+    healthy: boolean;
+    complete: boolean;
+    runtime: string;
+    containerId: string | null;
+    external: boolean;
+    takeover: boolean;
+    detail: string | undefined;
+    modelName: string;
+    baseUrl: string;
+  } | {
+    context: number;
+    prefill: number;
+    hostKvMiB: number;
+    draftTokens: number;
+    vision: boolean;
+    /** MTP n-gram drafts: `chain` speculates from the prompt and the running reply, `off` disables them. */
+    ngram: "off" | "chain";
+    /** Default response allowance; the engine and the chat model share the context window. */
+    outputTokens: number;
+    phase: string;
+    owned: boolean;
+    healthy: boolean;
+    complete: boolean;
+    containerId: string | null | undefined;
+    external: boolean;
+    takeover: boolean;
+    detail: string | undefined;
+    modelName: string;
+    baseUrl: string;
+  }>;
+  /** Return a bounded log tail from the configured owned runtime, or from the engine another launcher started. */
+  logs(): Promise<Record<string, unknown>>;
+  /** Persist tuning while the container and model API are stopped. */
+  configure(value: unknown): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  private stop;
+  /** Stop the external container that is provably this installation's engine. */
+  private takeOver;
+  /** Start, stop or restart the owned runtime, reclaiming only a container that is provably this engine. */
+  action(action: 'start' | 'stop' | 'restart'): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+}
+//#endregion
+//#region src/ninfer-log.d.ts
+/** Read the NInfer server log into the live figures its dashboard shows. */
+interface NInferLogSummary {
+  weightPercent?: number | undefined;
+  weightGiB?: number | undefined;
+  weightTotalGiB?: number | undefined;
+  weightBytesPerSecond?: number | undefined;
+  etaSeconds?: number | undefined;
+  decodeTokPerSecond?: number | undefined;
+  prefillTokPerSecond?: number | undefined;
+  running?: number | undefined;
+  batch?: number | undefined;
+  hostPercent?: number | undefined;
+  mtpAccepted?: number | undefined;
+  mtpOffered?: number | undefined;
+  mtpPercent?: number | undefined;
+  requests?: number | undefined;
+  error?: string | undefined;
+  listening?: boolean | undefined;
+  ready?: boolean | undefined;
+}
+/**
+ * Summarize the part of the log that belongs to the latest start.
+ *
+ * The log is append-only across restarts, so a new `starting engine` line ends
+ * the previous run's figures. A later `listening on` clears an earlier failure;
+ * a later `server stopped` clears the throughput that only describes a live run.
+ */
+declare function parseNInferLog(text: string): NInferLogSummary;
+//#endregion
+//#region src/engine-switch.d.ts
+/** Stop every other local engine before a start, so one GPU is never double-booked. */
+interface EngineMember {
+  /** User-facing engine name, e.g. "Strata". */
+  name: string;
+  /** Current phase and whether this Host may stop it. */
+  read: () => Promise<{
+    phase: string;
+    owned: boolean;
+  }>;
+  /** Stop the engine; resolved only after the request was accepted. */
+  stop: () => Promise<void>;
+}
+interface StopOptions {
+  wait?: (milliseconds: number) => Promise<void>;
+  timeoutMs?: number;
+  intervalMs?: number;
+}
+/**
+ * Stop the given engines, in order, and wait until each reports an idle phase.
+ *
+ * An engine this Host does not own is never stopped: the caller is told to stop
+ * it instead. A stop that does not settle within the timeout is an error, not a
+ * silent start against a half-freed GPU.
+ */
+declare function stopOtherEngines(members: EngineMember[], options?: StopOptions): Promise<string[]>;
+//#endregion
+//#region src/strata-profiles.d.ts
+/** Trusted deployment configuration; GUI requests select an id, never a path. */
+interface StrataProfile {
+  id: string;
+  name: string;
+  path: string;
+}
+/** List names and active model without exposing credentials or engine arguments.
+ * @param activePath Managed engine configuration reported by Strata.
+ * @param profiles Trusted, explicit model profiles.
+ * @returns Safe model choices and the id matching the current native weights.
+ */
+declare function strataProfiles(activePath: string, profiles: readonly StrataProfile[]): {
+  profiles: {
+    id: string;
+    name: string;
+  }[];
+  selected: string | null;
+};
+/** Preserve per-model tuning and authentication when changing the active config.
+ * @param activePath Managed engine config; caller must require a stopped server.
+ * @param profiles Trusted allowlist of configuration files.
+ * @param id Selected GUI profile id.
+ * @returns Selected id and a backup of the previous active configuration.
+ */
+declare function switchStrataProfile(activePath: string, profiles: readonly StrataProfile[], id: unknown): {
+  selected: string;
+  backup: string;
+};
+//#endregion
+//#region src/freetoken.d.ts
+/** Tuning persisted separately from model weights and download state. */
+interface FreeTokenSettings {
+  context: number;
+  threads: number;
+  prefill: number;
+  memoryRatio: number;
+  strategy: 'auto' | 'offload' | 'hybrid' | 'cpu';
+  vision: boolean;
+}
+/** Validate tuning entered through a GUI or saved configuration. */
+declare function validateFreeToken(value: unknown): FreeTokenSettings;
+/** Own one isolated runtime without stopping another provider or WSL distribution. */
+declare class FreeTokenController {
+  private readonly directory;
+  private readonly statusFile;
+  private changing;
+  readonly distribution: string;
+  readonly port: number;
+  readonly modelPath: string;
+  readonly runtime: string;
+  readonly alias: string;
+  readonly defaults: FreeTokenSettings;
+  constructor(config: {
+    directory: string;
+    statusFile: string;
+    distribution: string;
+    port: number;
+    modelPath: string;
+    runtime: string;
+    alias: string;
+    defaults: FreeTokenSettings;
+  });
+  /** Read tuning, using the configured defaults only when no tuning exists. */
+  settings(): FreeTokenSettings;
+  private verified;
+  private call;
+  /** Report process ownership and whether the model API responds. */
+  status(): Promise<{
+    context: number;
+    threads: number;
+    prefill: number;
+    memoryRatio: number;
+    strategy: "auto" | "offload" | "hybrid" | "cpu";
+    vision: boolean;
+    phase: string;
+    healthy: boolean;
+    complete: boolean;
+    modelName: string;
+    baseUrl: string;
+  }>;
+  /** Read a bounded tail of the owned server log. */
+  logs(): Promise<Record<string, unknown>>;
+  /** Save validated tuning only while this managed runtime is stopped. */
+  configure(value: unknown): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  /** Start or stop only the process whose Linux identity matches its saved owner. */
+  action(action: 'start' | 'stop' | 'restart'): Promise<Record<string, unknown>>;
+}
+//#endregion
+//#region src/strata-tuning.d.ts
+/** Read only supported numeric settings from an existing engine configuration.
+ * @param path Trusted config path reported by the local Strata service.
+ * @returns Available tunables, excluding private configuration fields.
+ */
+declare function readStrataTuning(path: string): Record<string, number>;
+/** Back up and replace supported flags while preserving all other configuration.
+ * @param path Trusted engine configuration path.
+ * @param values Validated GUI fields; the caller requires a stopped engine.
+ * @returns Backup location for manual recovery.
+ */
+declare function saveStrataTuning(path: string, values: Record<string, unknown>): string;
+//#endregion
+//#region src/ollama-tuning.d.ts
+/** Create a named Ollama variant with validated defaults, preserving the base model.
+ * @param body Installed base, new model name, and explicit generation defaults.
+ * @returns Completion message after Ollama confirms creation.
+ */
+declare function createOllamaVariant(body: Record<string, unknown>, endpoint?: string): Promise<{
+  ok: boolean;
+  detail: string;
+}>;
+//#endregion
+//#region src/engineering-tests.d.ts
+declare const engineeringTests: readonly [{
+  readonly id: "code-generation";
+  readonly name: "Code generation";
+  readonly description: "Generate and test a work-order hours calculator";
+  readonly brief: "Return ONLY JavaScript defining function pendingHours(rows). Each row has hours (finite nonnegative number) and status. Sum hours only for status \"pending\". Ignore invalid hours, cancelled/completed rows, null and non-object rows. Return 0 for non-array input. Do not mutate input. No imports, network, storage or explanations.";
+}, {
+  readonly id: "code-fixing";
+  readonly name: "Code repair";
+  readonly description: "Repair an off-by-one and falsy-value defect";
+  readonly brief: "Return ONLY corrected JavaScript defining function uniqueValues(items). Preserve insertion order and distinguish values by strict identity, including 0, false, empty strings, null and repeated objects. Return [] for non-array input; do not mutate it. Fix this implementation: function uniqueValues(items){const out=[];for(let i=0;i<=items.length;i++){if(items[i]&&!out.includes(items[i]))out.push(items[i]);}return out;} No imports or explanations.";
+}, {
+  readonly id: "plcopen";
+  readonly name: "PLCopen XML coding";
+  readonly description: "Structured Text motor start/stop latch in PLCopen XML";
+  readonly brief: "Return ONLY a complete PLCopen TC6 XML project in namespace http://www.plcopen.org/xml/tc6_0201. Include fileHeader and contentHeader, types/dataTypes and types/pous/pou named MotorLatch with pouType=\"program\". Declare BOOL input variables Start, Stop, EStop; BOOL output Run. Include an ST body with XHTML p text implementing Run := (Run OR Start) AND NOT Stop AND NOT EStop; EStop must take priority. Include instances/configurations. No external entities or DTD. This is an offline review fixture, not a deployable safety program.";
+}, {
+  readonly id: "l5x-generation";
+  readonly name: "Rockwell L5X coding";
+  readonly description: "Generate a routine export with defined tags and ladder rungs";
+  readonly brief: "Return ONLY a complete RSLogix5000Content L5X XML routine export with SchemaRevision=\"1.0\", SoftwareRevision=\"35.00\", TargetName=\"MotorLatch\", TargetType=\"Routine\", ContainsContext=\"true\". Controller Use=\"Context\" named BenchController; Program Use=\"Context\" named MainProgram with BOOL Base tags Start, Stop, EStop, Run in Tags; Routine Use=\"Target\" Name=\"MotorLatch\" Type=\"RLL\" with RLLContent and normal rung Number=\"0\" containing Text <![CDATA[XIO(EStop)XIO(Stop)[XIC(Start),XIC(Run)]OTE(Run);]]>. No DTD or external entities. Offline fixture only; do not claim Studio import verification.";
+}, {
+  readonly id: "l5x-identification";
+  readonly name: "Rockwell L5X identification";
+  readonly description: "Identify controller, program, routine, tags and priority";
+  readonly brief: "Return ONLY JSON with controller, program, routine, language, tags (array of tag names), emergencyStopTag, emergencyStopPriority (boolean). Analyze: <RSLogix5000Content><Controller Name=\"BenchController\"><Programs><Program Name=\"MainProgram\"><Tags><Tag Name=\"Start\" DataType=\"BOOL\"/><Tag Name=\"Stop\" DataType=\"BOOL\"/><Tag Name=\"EStop\" DataType=\"BOOL\"/><Tag Name=\"Run\" DataType=\"BOOL\"/></Tags><Routines><Routine Name=\"MotorLatch\" Type=\"RLL\"><RLLContent><Rung><Text><![CDATA[XIO(EStop)XIO(Stop)[XIC(Start),XIC(Run)]OTE(Run);]]></Text></Rung></RLLContent></Routine></Routines></Program></Programs></Controller></RSLogix5000Content>";
+}];
+/** Run bounded, offline browser checks for generated JavaScript, XML or JSON.
+ * @param source Model answer, retained in the benchmark result.
+ * @param id Stable task identifier.
+ * @param pw Playwright browser API.
+ * @param executablePath Installed Chromium executable.
+ * @param signal Cancellation signal.
+ * @returns Named checks and their percentage score; XML checks do not certify PLC imports.
+ */
+declare function inspectEngineering(source: string, id: string, pw: any, executablePath: string, signal: AbortSignal): Promise<{
+  checks: {
+    name: string;
+    passed: boolean;
+  }[];
+  score: number;
+  validationNote: string;
+}>;
+//#endregion
+//#region src/tuning.d.ts
+/** Validate persisted or GUI-supplied tuning without accepting arbitrary launch flags.
+ * @param input Complete profile fields.
+ * @returns A normalized profile with explicit defaults for optional controls.
+ */
+declare function validateTuning(input: Record<string, unknown>): Record<string, string | number | boolean>;
+/** Render validated controls as discrete argv values.
+ * @param profile Normalized model tuning.
+ * @returns Flags consumed by the managed llama.cpp server.
+ */
+declare function tuningArgs(profile: Record<string, string | number | boolean>): string[];
+//#endregion
+//#region src/remote.d.ts
+type Data$3 = Record<string, any>;
+declare function remoteAddress(value: unknown): string;
+declare function allowedControl(path: string, method: string): {
+  path: string;
+  engine: string | undefined;
+  action: string;
+};
+/** Admit a browser paired through AryaAI's existing session and Host/Origin checks. */
+declare function controlCaller(req: IncomingMessage, ctx: any): boolean;
+declare class RemoteStore {
+  state: Data$3;
+  readonly file: string;
+  constructor(directory?: string);
+  save(): void;
+  view(): {
+    enabled: boolean;
+    pairs: any;
+    connection: {
+      address: any;
+      paired: boolean;
+    } | null;
+  };
+  pair(label: unknown): {
+    id: string;
+    token: string;
+  };
+  authorized(token: string): any;
+  revoke(id: unknown): void;
+  connect(address: unknown, token: unknown): {
+    address: string;
+    token: string;
+  };
+}
+declare class ActivityGate {
+  readonly busy: () => boolean;
+  active: number;
+  changing: boolean;
+  constructor(busy: () => boolean);
+  enter(): () => void;
+  change<T>(check: () => Promise<void>, action: () => Promise<T>): Promise<T>;
+}
+declare class RemoteClient {
+  readonly store: RemoteStore;
+  readonly fetcher: typeof fetch;
+  constructor(store: RemoteStore, fetcher?: typeof fetch);
+  request(operation: string, payload?: Data$3, connection?: any, signal?: AbortSignal): Promise<Response>;
+  inventory(connection?: any, signal?: AbortSignal): Promise<Data$3[]>;
+}
+/** Native chunk relay preserves AryaAI tool calls, reasoning and usage accounting. */
+declare class RemoteAdapter {
+  readonly client: RemoteClient;
+  readonly attachments: any;
+  constructor(client: RemoteClient, attachments: any);
+  providerInfo(provider: string): {
+    id: string;
+    name: string;
+  };
+  providerRetryPolicy(): {
+    mode: string;
+    maxRetries: number;
+    retryableCodes: never[];
+    initialDelayMs: number;
+    maxDelayMs: number;
+    jitterRatio: number;
+  };
+  imageRequestPricing(): undefined;
+  listModels(): Promise<{
+    provider: string;
+  }[]>;
+  resolveModel(provider: string, id: string, signal?: AbortSignal, connection?: any): Promise<Data$3>;
+  prepareCall(provider: string, id: string, signal?: AbortSignal): Promise<{
+    model: Data$3;
+    stream: (options: Data$3) => AsyncGenerator<any, void, any>;
+  }>;
+  stream(options: Data$3): AsyncGenerator<any, void, any>;
+  streamAt(options: Data$3, connection: Data$3 | null): AsyncGenerator<any, void, any>;
+}
+type HostOptions = {
+  models: () => Promise<Data$3[]>;
+  stream: (options: Data$3) => AsyncIterable<Data$3>;
+  ensure: (model: Data$3) => Promise<void>;
+  ready?: (model: Data$3) => Promise<boolean>;
+  checkIdle: () => Promise<void>;
+  base: string;
+  attachments: any;
+  gate: ActivityGate;
+  wireEndpoint?: (model: Data$3) => string;
+  authorizeDevice?: (token: string) => boolean;
+};
+declare function mountRemote(ctx: any, store: RemoteStore, host: HostOptions, llm: any): (() => void) & {
+  refresh: () => any;
+};
+//#endregion
+//#region src/api-benchmarks.d.ts
+type Data$2 = Record<string, any>;
+/** Reuse registered adapters and credentials; nothing secret goes in the inventory or run files. */
+declare class ApiBenchmarks {
+  readonly llm: any;
+  readonly attachments: any;
+  readonly localProviders: string[];
+  private replay;
+  constructor(llm: any, attachments: any, localProviders?: string[]);
+  models(): Promise<Data$2[]>;
+  complete(provider: string, model: string, body: Data$2, signal: AbortSignal): Promise<{
+    content: string;
+    reasoning: boolean;
+    calls: Data$2[];
+    finishReason: string;
+    api: boolean;
+    reasoningEffort: any;
+    contextWindow: any;
+    metrics: {
+      ttftMs: number | null;
+      elapsedMs: number;
+      outputTokens: any;
+      promptTokens: any;
+      cachedTokens: any;
+      reasoningTokens: any;
+      tps: number | null;
+      tpsSource: string;
+      promptMs: null;
+    };
+  }>;
+}
+//#endregion
+//#region src/benchmarks.d.ts
+type Data$1 = Record<string, any>;
+declare function validateRun(body: Data$1): Data$1;
+declare function parseStreamEvent(data: Data$1, state: Data$1): void;
+declare function complete(endpoint: string, model: string, body: Data$1, signal: AbortSignal, headers?: Record<string, string>): Promise<{
+  content: any;
+  reasoning: boolean;
+  calls: any;
+  finishReason: any;
+  metrics: {
+    ttftMs: any;
+    elapsedMs: number;
+    outputTokens: any;
+    promptTokens: any;
+    cachedTokens: any;
+    tps: any;
+    tpsSource: string;
+    promptMs: any;
+  };
+}>;
+declare class Benchmarks {
+  readonly controller: any;
+  readonly api?: ApiBenchmarks | undefined;
+  readonly freeToken?: FreeTokenController | undefined;
+  readonly ninfer?: NInferController | undefined;
+  controlBase: () => string;
+  readonly folder: string;
+  private active;
+  private strataHeaders;
+  private headers;
+  private complete;
+  constructor(controller: any, api?: ApiBenchmarks | undefined, freeToken?: FreeTokenController | undefined, ninfer?: NInferController | undefined);
+  /** Report browser prerequisites before any model is interrupted. */
+  environment(): {
+    available: boolean;
+    runtime: string;
+    executable: string;
+    detail: string;
+  };
+  private browserTools;
+  busy(): boolean;
+  private save;
+  history(): any[];
+  get(id: string): any;
+  exportZip(id: string): Buffer<ArrayBuffer>;
+  remove(body: Data$1): {
+    ok: boolean;
+    deleted: string[];
+    detail: string;
+  };
+  cancel(): {
+    ok: boolean;
+    detail: string;
+  };
+  rate(body: Data$1): {
+    ok: boolean;
+  };
+  asset(runId: string, key: string, file: string): NonSharedBuffer;
+  models(): Promise<Data$1[]>;
+  private catalog;
+  private gpu;
+  private readiness;
+  start(body: Data$1): Promise<{
+    ok: boolean;
+    id: any;
+  }>;
+  private localControl;
+  private wait;
+  private perform;
+}
+//#endregion
+//#region src/comparisons.d.ts
+type Data = Record<string, any>;
+declare function comparisonColumns(runs: Data[]): any[];
+//#endregion
+//#region src/website-tests.d.ts
+declare const websiteTests: readonly [{
+  readonly id: "landing";
+  readonly name: "Product launch";
+  readonly description: "Marketing, pricing and newsletter signup";
+  readonly brief: "Build a polished product launch site for Orbit, a local AI assistant. Include hero, features, three pricing cards, testimonials and newsletter signup. Email input data-testid=\"email\", subscribe button \"subscribe\", feedback \"feedback\". Valid email submission must show \"Subscribed\" in feedback without navigating. Include a theme toggle \"theme-toggle\" that changes the document.documentElement data-theme between light and dark.";
+}, {
+  readonly id: "dashboard";
+  readonly name: "Analytics dashboard";
+  readonly description: "Charts, searchable data and a period filter";
+  readonly brief: "Build a polished analytics dashboard for a coffee business. Include KPI cards and a chart drawn with inline SVG or canvas. Add period select data-testid=\"period\" with options week and month, and revenue figure \"revenue\" that visibly changes between periods. Include customer rows each data-testid=\"customer-row\", one containing Maya Chen and one Alex Rivera; search input \"search\" must filter those rows by customer name.";
+}, {
+  readonly id: "store";
+  readonly name: "Online store";
+  readonly description: "Product filtering and working shopping cart";
+  readonly brief: "Build a premium outdoor equipment store with six products, product cards and a shopping cart. Give each visible product card data-testid=\"product\". Include a product named Trail Pack and another named Camp Light. Search input \"search\" filters visible products. A button data-testid=\"add-cart\" on the first product adds one item to the cart; cart count \"cart-count\" starts at 0 and increases to 1. Clear-cart button \"clear-cart\" resets count to 0.";
+}, {
+  readonly id: "kanban";
+  readonly name: "Kanban workspace";
+  readonly description: "Create, filter and move project tasks";
+  readonly brief: "Build a professional three-column kanban board with Todo, Doing and Done. Each card has data-testid=\"task\" and a status label. Create task input \"task-title\" and button \"add-task\" must add a visible card with that title. Search input \"search\" filters task cards. The new task must have a button \"move-task\" that moves that card from Todo to Doing, visibly updating its status to Doing.";
+}, {
+  readonly id: "booking";
+  readonly name: "Booking experience";
+  readonly description: "Accessible form validation and confirmation";
+  readonly brief: "Build an attractive appointment booking page for a wellness studio, including service information and availability. Provide form fields data-testid=\"name\", \"email\", \"date\" (type date), and submit button \"book\". Mark all three required and label them accessibly. Empty submission must not show a confirmation. Valid submission must show \"Booking confirmed\" in a visible element data-testid=\"confirmation\", without navigating or network requests.";
+}, {
+  readonly id: "docs";
+  readonly name: "Documentation portal";
+  readonly description: "Navigation, content search and accordion";
+  readonly brief: "Build a professional developer documentation portal with sidebar, article and code examples. Sidebar button data-testid=\"api-tab\" switches the article data-testid=\"article\" to API Reference content. Search input \"search\" filters navigation entries data-testid=\"doc-link\"; include Getting Started and API Reference entries. FAQ question button data-testid=\"faq-toggle\" expands an initially hidden answer data-testid=\"faq-answer\" containing \"offline\".";
+}, {
+  readonly id: "snake";
+  readonly name: "Snake game";
+  readonly description: "Keyboard movement, food growth, collision and reset";
+  readonly brief: "Build a playable 10x10 Snake game with keyboard arrow controls, start/pause, score, reset data-testid=\"reset\", and manual tick button \"step\". Start paused. Initial snake cells are [[3,2],[2,2],[1,2]], heading right, food [4,2], score 0. Expose live JSON in a visible details element data-testid=\"game-state\" with snake (array of [x,y]), food, score, direction and gameOver. Each Step advances one cell even while paused. Eating food grows by one and raises score by 1. Ignore immediate reversal. Wall and self collisions set gameOver=true and stop movement. Reset restores the exact initial state. Render the board and snake visibly; playable on mobile with direction buttons.";
+}, {
+  readonly id: "tetris";
+  readonly name: "Tetris game";
+  readonly description: "Movement, rotation, hard drop, line clearing and restart";
+  readonly brief: "Build playable 10x20 Tetris with arrow movement, up-arrow rotation, space hard drop, pause, restart data-testid=\"reset\". Start paused with an empty board and a T piece at x=3,y=0, rotation=0. Expose live JSON in visible details data-testid=\"game-state\" with x,y,rotation,lines,score,gameOver and board (20 arrays of 10 cells). Button \"line-fixture\" loads a deterministic line-clear scenario: bottom four rows filled except column 4, active vertical I piece above that column. Button \"hard-drop\" locks the active piece and clears complete lines, adds 4 to lines and increases score for that fixture. ArrowRight changes x, ArrowUp changes rotation without leaving the board. Restart resets lines and score to 0 and empties board. Visibly render board, piece and score, include mobile controls. All fixtures and state must drive the actual game logic.";
+}];
+declare function extractHtml(text: string): string;
+declare function isolatedHtml(html: string): string;
+declare function inspectWebsite(html: string, id: string, folder: string, pw: any, executablePath: string, signal: AbortSignal): Promise<{
+  checks: {
+    name: string;
+    passed: boolean;
+    detail?: string;
+  }[];
+  score: number;
+  errors: string[];
+}>;
+//#endregion
+//#region src/index.d.ts
+declare const name = "@aryacode/dsh-local-llm";
+declare const inject: string[];
+/** Phases where the llama.cpp controller holds no model server: nothing to stop first. */
+declare function engineIdle(phase: string): phase is "stopped" | "missing-model";
+declare class ServerController {
+  directory: string;
+  readonly benchmarkRuntimeDirectory: string;
+  readonly port: number;
+  context: number;
+  cpuMoeLayers: number;
+  threads: number;
+  selectedModel: string;
+  selectedVision: string;
+  runtimeExecutable: string | undefined;
+  ollamaUrl: string;
+  readonly preferencesDirectory: string;
+  webUiUrls: Record<string, string>;
+  settingsIssue: string | undefined;
+  private busy;
+  constructor(config?: {
+    directory?: string;
+    port?: number;
+    context?: number;
+    cpuMoeLayers?: number;
+    threads?: number;
+    benchmarkRuntimeDirectory?: string;
+    preferencesDirectory?: string;
+    executable?: string;
+    ollamaUrl?: string;
+  });
+  get exe(): string;
+  private validateOllamaUrl;
+  setup(): {
+    directory: string;
+    webUiUrls: Record<string, string>;
+    executable: string;
+    runtimeInstalled: boolean;
+    ollamaUrl: string;
+    platform: NodeJS.Platform;
+    engines: {
+      id: string;
+      name: string;
+      installUrl: string;
+      detail: string;
+    }[];
+  };
+  setupEngine(value: Record<string, unknown>): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  get model(): string;
+  get vision(): string;
+  private readPresets;
+  private inspectPresets;
+  modelPresets(): Record<string, Record<string, any>>;
+  modelSettings(file: string): {
+    context: any;
+    threads: any;
+    cpuMoeLayers: any;
+    selectedVision: any;
+  } | null;
+  private validateSettings;
+  configure(body: Record<string, unknown>): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  /** Save a validated per-model profile while the managed server is stopped. */
+  savePreset(body: Record<string, unknown>): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  /** Remove an inactive model file and its profile without affecting other models. */
+  removeModel(file: unknown): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+  get ownerPath(): string;
+  private owner;
+  private identity;
+  private owned;
+  logs(): string;
+  status(): Promise<{
+    phase: string;
+    owned: boolean;
+    pid: number | null;
+    downloadPercent: number;
+    complete: boolean;
+    runtimeInstalled: boolean;
+    settingsIssue: string | undefined;
+    healthy: boolean;
+    gpu: string | null;
+    ramUsedGiB: number;
+    ramTotalGiB: number;
+    context: number;
+    cpuMoeLayers: number;
+    threads: number;
+    selectedModel: string;
+    selectedVision: string;
+    presets: Record<string, Record<string, any>>;
+    presetIssues: Record<string, string>;
+    webUiUrl: string;
+    cacheType: any;
+    moeCacheMiB: any;
+    baseUrl: string;
+    model: any;
+    logs: string;
+  }>;
+  action(action: string): Promise<{
+    ok: boolean;
+    detail: string;
+  }>;
+}
+declare function apply(ctx: Context, config?: ConstructorParameters<typeof ServerController>[0] & {
+  connectionDirectory?: string;
+  webPort?: number;
+  freeToken?: ConstructorParameters<typeof FreeTokenController>[0];
+  ninfer?: ConstructorParameters<typeof NInferController>[0];
+  webUiUrls?: Record<string, string>;
+  strataProfiles?: readonly StrataProfile[];
+  strata?: StrataConfig;
+}): void;
+//#endregion
+export { ActivityGate, ApiBenchmarks, Benchmarks, type EngineMember, FreeTokenController, LIBRARY_PROVIDER, type NInferContainer, NInferController, type NInferLogSummary, RemoteAdapter, RemoteClient, RemoteStore, ServerController, type StopOptions, StrataService, allowedControl, apply, apply$1 as applyStrataRoutes, comparisonColumns, complete, controlCaller, createOllamaVariant, engineIdle, engineeringTests, extractHtml, hardwareCollector, inject, inspectEngineering, inspectWebsite, isolatedHtml, libraryAdapter, linkedTarget, mountRemote, mountRoutes as mountStrataRoutes, name, outputDefault, ownsNInfer, parseNInferLog, parseStreamEvent, readStrataTuning, reclaimsNInfer, remoteAddress, saveStrataTuning, startPairRelay, stopOtherEngines, strataProfiles, switchStrataProfile, tuningArgs, validateFreeToken, validateNInfer, validateRun, validateTuning, websiteTests };