dsh-plugin-local-infer 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },
@@ -21,6 +21,10 @@
     "ai-agent"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cybtachyon/dsh-plugin-local-infer"
+  },
   "type": "module",
   "packageManager": "pnpm@12.11.2",
   "engines": {
@@ -99,6 +103,7 @@
     "@types/node": "^22.10.0",
     "@vitest/coverage-v8": "^5.0.4",
     "eslint": "^10.12.0",
+    "tsx": "^4.23.15",
     "typescript": "^5.9.0",
     "typescript-eslint": "^8.71.2",
     "vite-tsconfig-paths": "^5.1.4",

package/packages/core/lib/adapter.d.ts

@@ -5,6 +5,13 @@ import type { HardwareProfile } from './hardware.ts';
 import type { ParameterSpec } from './parameter.ts';
 import type { SystemDep } from './deps.ts';
 import type { EngineLaunchSignature } from './reserve.ts';
+/**
+ * BuildMode is the deploy mode an engine renders a plan for: a docker
+ * container, a local source build, or a prebuilt binary install (the Strata
+ * Terminal the install script places on the path). The adapter reads it from
+ * the config `buildMode` field and renders the matching plan.
+ */
+export type BuildMode = 'docker' | 'local' | 'binary';
 /**
  * LaunchPlan is the engine-neutral result of rendering a config: how to start
  * the engine (a local process, a docker container, or a compose file), the
@@ -135,14 +142,26 @@ export type LaunchStep = 'prereqs' | 'download' | 'build' | 'launch';
  * and the adapter's deploy step; a launch with no progress sink omits it.
  */
 export type LaunchProgress = (step: LaunchStep) => void;
+/**
+ * EngineLaunchState is the phase of an engine start the health poll reports:
+ * downloading (the engine is fetching its engine or model files, the health
+ * endpoint is not up yet), starting (the files are in place and the engine is
+ * coming up), ready (the health endpoint reports 200), and failed (the start
+ * did not reach readiness). An engine that downloads before it can serve (the
+ * Strata Terminal) spends a long time in downloading, so the poll reports the
+ * phase instead of timing out and reading the start as broken.
+ */
+export type EngineLaunchState = 'downloading' | 'starting' | 'ready' | 'failed';
 /**
  * HealthResult is the answer to a /health poll: whether the engine is up, the
- * HTTP status, and a detail string for the UI.
+ * HTTP status, a detail string for the UI, and the start phase the poll
+ * observed (absent for an engine whose start has no download phase).
  */
 export interface HealthResult {
     healthy: boolean;
     status?: number;
     detail?: string;
+    state?: EngineLaunchState;
 }
 /**
  * DeployOptions tunes a deploy run: `allowRunDeps` is the Play/Run trust gate
@@ -190,6 +209,7 @@ export declare abstract class EngineAdapter {
     abstract readonly supports: {
         docker: boolean;
         local: boolean;
+        binary?: boolean;
     };
     abstract parameters(): readonly ParameterSpec[];
     abstract renderLaunch(config: Config, hw: HardwareProfile): LaunchPlan;
@@ -202,7 +222,7 @@ export declare abstract class EngineAdapter {
      * registered adapter first and falls back to the provider-registered plan
      * for the engine id when the adapter declares none.
      */
-    systemDeps?(buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+    systemDeps?(buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
     /**
      * Optional: the model the engine serves under a config: the id the engine
      * advertises on its OpenAI endpoint and the display name the registrar
@@ -214,6 +234,28 @@ export declare abstract class EngineAdapter {
         id: string;
         name: string;
     } | undefined;
+    /**
+     * Optional: the model the running engine actually serves, read live from the
+     * engine (a terminal query against its model endpoint) rather than derived
+     * from the config. An engine that sizes and picks the model itself publishes
+     * the served id this returns instead of the config-derived modelRef; it
+     * returns undefined when the engine is not up, the answer cannot be read, or
+     * the config names a model, and the route falls back to modelRef. The
+     * register, save-sync, unregister, and summary paths await it, so it must
+     * never reject.
+     */
+    discoverModel?(config: Config): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    /**
+     * Optional: the request modalities the engine serves under a config, the
+     * input types the DSH model row carries. An engine whose vision control is
+     * not the plain boolean flag (Strata's on|off|gpu|cpu enum, on by default)
+     * declares this so the Image input follows the engine's own vocabulary; an
+     * engine that declares none keeps the register step's boolean rule.
+     */
+    modelInput?(config: Config): string[] | undefined;
     /**
      * Optional: the launch signature the engine's toArgv/toEnv produce for a
      * config: the binary (or docker image) it runs under, the port it binds,

package/packages/core/lib/deps.d.ts

@@ -1,4 +1,4 @@
-import type { EngineAdapter } from './adapter.ts';
+import type { BuildMode, EngineAdapter } from './adapter.ts';
 import type { HardwareProfile } from './hardware.ts';
 /**
  * DepStatus is the lifecycle state of one host dependency: satisfied, missing,
@@ -60,6 +60,7 @@ export interface SystemDep {
 export interface EngineDepPlan {
     docker: readonly SystemDep[];
     local: readonly SystemDep[];
+    binary?: readonly SystemDep[];
 }
 /**
  * DepCheck is the per-dep answer from checkDeps: the dep and its current
@@ -103,7 +104,7 @@ export interface InstallResult {
  * service implements this interface over the pure functions below.
  */
 export interface SystemDepProvisioner {
-    planDeps(engine: EngineAdapter, buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+    planDeps(engine: EngineAdapter, buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
     checkDeps(deps: readonly SystemDep[], hw: HardwareProfile): Promise<DepCheck[]>;
     renderInstallString(deps: readonly SystemDep[], hw: HardwareProfile): string;
     runInstall(deps: readonly SystemDep[], hw: HardwareProfile, runCommand: CommandRunner): Promise<InstallResult>;
@@ -122,7 +123,7 @@ export declare function detectPackageManager(probes: PackageManagerProbes): Pack
  * declares none (the Phase 5 adapters will) plans an empty list, and the
  * service falls back to the provider-registered plan for the engine id.
  */
-export declare function planDeps(engine: EngineAdapter, buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+export declare function planDeps(engine: EngineAdapter, buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
 /**
  * checkDeps probes every dep and reports its status. A dep without a detect
  * probe reads as missing, not satisfied: an unknown state degrades to the

package/packages/core/lib/index.d.ts

@@ -20,7 +20,7 @@ export { computeProviderStatuses, isGpuBusy, } from './status.ts';
 export type { ProviderRef, ProviderStatus, ProviderStatusInput, RunningEngineRef, } from './status.ts';
 export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from './logs.ts';
 export { EngineAdapter } from './adapter.ts';
-export type { DeployOptions, DeployResult, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LaunchProgress, LaunchStep, LifecycleHost, ProcessExitInfo, ProcessHandle, } from './adapter.ts';
+export type { BuildMode, DeployOptions, DeployResult, EngineLaunchState, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LaunchProgress, LaunchStep, LifecycleHost, ProcessExitInfo, ProcessHandle, } from './adapter.ts';
 export { NOOP_DEBUG_LOGGER, createCommandDebugLogger, isHarnessLogDebug, } from './debug.ts';
 export type { CreateCommandDebugLoggerArgs, DebugLogger, } from './debug.ts';
 export { constraintId, evaluateGuidelines, modelGuidelines } from './guideline.ts';

package/packages/core/lib/registrar.d.ts

@@ -1,4 +1,4 @@
-import type { LaunchPlan } from './adapter.ts';
+import type { BuildMode, LaunchPlan } from './adapter.ts';
 /**
  * DshModelEntry is the shape of the model row the registrar writes into the
  * dsh-llm-pi-ai provider: the provider id, the model id and display name, the
@@ -83,11 +83,11 @@ export interface DshModelRegistrar {
 export declare function modelSlug(modelId: string): string;
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
-export declare function providerIdFor(engineId: string, modelId: string, buildMode: 'local' | 'docker'): string;
+export declare function providerIdFor(engineId: string, modelId: string, buildMode: BuildMode): string;
 /**
  * apiKeyEnvFor derives the env-var name a local provider reads its optional
  * API key from: the engine id, uppercased and non-alphanumerics mapped to

package/packages/core/lib/registrar.js

@@ -27,9 +27,9 @@ export function modelSlug(modelId) {
 }
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
 export function providerIdFor(engineId, modelId, buildMode) {
     return `${engineId}-${buildMode}-${modelSlug(modelId)}`;

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-core",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Pure, framework-free domain model for the dsh local-inference plugin: ParameterSpec, HardwareProfile, EngineAdapter, VramEstimator, GuidelineEngine, DefaultsResolver, DshModelRegistrar, and SystemDepProvisioner primitives shared by every engine and model",
   "keywords": [
     "dsh",

package/packages/providers/lib/acquire.d.ts

@@ -31,8 +31,8 @@ export declare const FORK_REMOTE = "dsh-fork";
  * through cmake (Infernix through its own preset); llama.cpp builds through
  * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
  * engine, so it carries no local build steps (the compose up pulls the
- * image); Strata is the placeholder engine, and its repo and pull step land
- * with the engine, the same way its docker image constant did.
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout.
  */
 export declare const ENGINE_SOURCES: Record<string, EngineSource>;
 /**
@@ -86,6 +86,8 @@ export interface SyncRebuildRequest {
     fork?: string;
     binary?: string;
     allowRunDeps?: boolean;
+    buildCommands?: string;
+    onBuildStart?: () => void;
 }
 /**
  * SyncRebuildResult reports the conditional rebuild: whether it passed,
@@ -121,5 +123,5 @@ export declare function syncAndRebuildEngine(host: LifecycleHost, request: SyncR
  * engines) passes through with a note; a failing step stops the build with
  * the step's detail.
  */
-export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog): Promise<EngineStepResult>;
+export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog, buildCommands?: string): Promise<EngineStepResult>;
 //# sourceMappingURL=acquire.d.ts.map

package/packages/providers/lib/acquire.js

@@ -18,8 +18,8 @@ export const FORK_REMOTE = 'dsh-fork';
  * through cmake (Infernix through its own preset); llama.cpp builds through
  * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
  * engine, so it carries no local build steps (the compose up pulls the
- * image); Strata is the placeholder engine, and its repo and pull step land
- * with the engine, the same way its docker image constant did.
+ * image); Strata builds through its own setup.sh (the README's
+ * Build-from-source route), which the source-build mode runs in the checkout.
  */
 export const ENGINE_SOURCES = {
     ninfer: {
@@ -47,9 +47,13 @@ export const ENGINE_SOURCES = {
         buildSteps: ['cd {dir} && cmake --preset release && cmake --build build -j'],
     },
     strata: {
-        repo: 'https://github.com/strata/strata',
+        // The README's Build-from-source route: git clone the repo, then run the
+        // engine's own setup.sh. `--yes` takes the recommended answer to every
+        // question (no prompts) and `--no-start` builds and installs the engine
+        // without starting the server, which the adapter's launch step then does.
+        repo: 'https://github.com/Niko1221/Strata',
         branch: 'main',
-        buildSteps: ['docker pull ghcr.io/strata/strata'],
+        buildSteps: ['cd {dir} && ./setup.sh --yes --no-start'],
     },
 };
 /**
@@ -264,8 +268,20 @@ export async function syncAndRebuildEngine(host, request, log) {
         }
     }
     if (rebuilt) {
-        // Run the engine's build steps, capturing the command and its output.
-        for (const step of source.buildSteps) {
+        // The user's local build command (the card's Build commands field)
+        // overrides the engine's default build steps: it runs in the checkout, so
+        // it is wrapped with a cd into the directory. Absent falls back to the
+        // engine's acquisition build steps.
+        const buildCommands = request.buildCommands !== undefined && request.buildCommands.trim() !== ''
+            ? request.buildCommands
+            : undefined;
+        const steps = buildCommands !== undefined
+            ? [`cd ${directory} && ${buildCommands}`]
+            : source.buildSteps;
+        // Report the build phase before the first step runs, so the card's button
+        // reads "Building..." while the build is in flight, not after it completes.
+        request.onBuildStart?.();
+        for (const step of steps) {
             const command = step.replaceAll('{dir}', directory);
             const outcome = await runLogged(host, command, emit);
             if (!outcome.ok) {
@@ -304,16 +320,21 @@ export async function syncAndRebuildEngine(host, request, log) {
  * engines) passes through with a note; a failing step stops the build with
  * the step's detail.
  */
-export async function buildEngineRepo(host, engineId, directory, log) {
+export async function buildEngineRepo(host, engineId, directory, log, buildCommands) {
     const source = engineSource(engineId);
     if (source === undefined) {
         return { ok: false, detail: `no engine source is registered for "${engineId}"` };
     }
-    if (source.buildSteps.length === 0) {
+    // The user's local build command (the card's Build commands field) overrides
+    // the engine's default build steps: it runs in the checkout, so it is wrapped
+    // with a cd into the directory. Absent falls back to the engine's steps.
+    const commands = buildCommands !== undefined && buildCommands.trim() !== '' ? buildCommands : undefined;
+    const steps = commands !== undefined ? [`cd ${directory} && ${commands}`] : source.buildSteps;
+    if (steps.length === 0) {
         log(`no local build steps for ${engineId}\n`);
         return { ok: true };
     }
-    for (const step of source.buildSteps) {
+    for (const step of steps) {
         const command = step.replaceAll('{dir}', directory);
         const outcome = await runLogged(host, command, log);
         if (!outcome.ok) {

package/packages/providers/lib/adapters.d.ts

@@ -1,33 +1,13 @@
 /**
- * The concrete engine adapters: NInfer (docker and local) and Hyper-Qwen
- * (compose). Each composes the provider `ParameterSpec` data into a
- * `LaunchPlan` and drives its deploy, health-check, and stop steps through an
- * injectable `LifecycleHost`, so the tests stub the host and never run a real
- * build, docker, or network in CI. The node implementation
- * (`nodeLifecycleHost`) is what the service wires in on a live host.
+ * The shared engine-adapter helpers: the spec-to-argv and spec-to-env
+ * translators the concrete adapters (the `engines/*Adapter.ts` files) compose
+ * into a `LaunchPlan`, the card's Custom Arguments translators, the
+ * `LifecycleHost` the deploy, health-check, and stop steps drive, and the
+ * health poll. The node implementation (`nodeLifecycleHost`) is what the
+ * service wires in on a live host.
  * @module dsh-plugin-local-infer/providers/adapters
  */
-import { EngineAdapter } from '../../core/lib/index.js';
-import type { Config, DebugLogger, DeployOptions, DeployResult, EngineLaunchSignature, EnginePlatformConfig, HealthCheckOptions, HealthResult, HardwareProfile, LaunchPlan, LaunchProgress, LifecycleHost, ParameterSpec } from '../../core/lib/index.js';
-export { INFERNIX_MODEL_ARTIFACTS } from './infernix.ts';
-/**
- * NInferModelArtifact is the per-model deploy data: the `.ninfer` artifact
- * file, the Hugging Face repo the model download pulls it from, and the
- * `--model-id` alias the server advertises. The data is the surface; adding a
- * model is a data edit here, never an adapter rewire.
- */
-export interface NInferModelArtifact {
-    file: string;
-    repo: string;
-    modelId: string;
-}
-/**
- * The NInfer model artifacts, keyed by the model registry id. The 27B entry
- * is the default the DEFAULT_MODELS list names; the 35B-A3B entries are the
- * Qwen3.8 measured artifact (`qwen3-35b`) and the Qwen3.6 default
- * (`qwen36-35b`).
- */
-export declare const NINFER_MODEL_ARTIFACTS: Record<string, NInferModelArtifact>;
+import type { Config, DebugLogger, HealthCheckOptions, HealthResult, LaunchPlan, LifecycleHost, ParameterSpec, ProcessHandle } from '../../core/lib/index.js';
 /**
  * flagsFromSpecs turns a spec surface and a config into the CLI flag list: each
  * spec's `toArgv` runs over the config value (falling back to the spec
@@ -76,6 +56,14 @@ export declare function createNodeLifecycleHost(debug?: DebugLogger): LifecycleH
  * in debug mode.
  */
 export declare const nodeLifecycleHost: LifecycleHost;
+/**
+ * trackChild stores a spawned handle in the adapter's children map and ties
+ * the entry's lifetime to the child's: when the child ends (a crash, a pkill,
+ * or the adapter's own stop kill) the entry is dropped, so a later stop never
+ * signals a pid a recycled process has taken over. A handle whose host cannot
+ * watch (onExit absent) stays tracked until stop removes it.
+ */
+export declare function trackChild(children: Map<string, ProcessHandle>, key: string, handle: ProcessHandle): void;
 /**
  * pollHealth polls a plan's health URL until a 200 or the attempt cap, the
  * same loop the qwen-ninfer launcher runs. A poll interval of 0 skips the
@@ -83,187 +71,9 @@ export declare const nodeLifecycleHost: LifecycleHost;
  */
 export declare function pollHealth(host: LifecycleHost, plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
 /**
- * The NInfer docker image the adapter pulls and runs. The engineFork platform
- * config overrides the git source for a local build; the image stays the
- * upstream ghcr artifact.
- */
-export declare const NINFER_DOCKER_IMAGE = "ghcr.io/iamwavecut/ninfer-all";
-/**
- * NInferAdapter is the canonical both-capable engine. `renderLaunch` renders a
- * local `ninfer-serve` process or a `docker run` of the ghcr image from the
- * same spec surface; `deploy` builds the engine in the engine directory (or
- * pulls the image), downloads the model into the model directory, and starts
- * the engine; `healthCheck` polls the health URL; `stop` signals the tracked
- * process and stops the named container.
- */
-export declare class NInferAdapter extends EngineAdapter {
-    readonly id = "ninfer";
-    readonly supports: {
-        docker: boolean;
-        local: boolean;
-    };
-    private readonly host;
-    private readonly children;
-    constructor(host?: LifecycleHost);
-    parameters(): readonly ParameterSpec[];
-    modelRef(config: Config): {
-        id: string;
-        name: string;
-    };
-    launchSignature(config?: Config): EngineLaunchSignature;
-    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
-    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private buildMode;
-    private port;
-    private planKey;
-    private downloadModel;
-    /**
-     * resolveChatTemplate rewrites a --chat-template flag that carries an HF repo
-     * reference into the local file the engine reads. A value with a slash that
-     * is not an absolute path (the combo control's known choices) is a repo the
-     * deploy step downloads into the model directory; an already-local path is
-     * left as-is. The download is best-effort: a template that is already on
-     * disk is used without a re-fetch, and a missing hf CLI leaves the flag
-     * untouched so the engine reports the missing template itself.
-     */
-    private resolveChatTemplate;
-}
-/**
- * HyperQwenAdapter is the docker-compose engine. `renderLaunch` renders a
- * compose plan (the compose file, the profile, and the `.env` the spec surface
- * maps to); `deploy` runs `docker compose up`; `healthCheck` polls the health
- * URL; `stop` runs `docker compose down`.
- */
-export declare class HyperQwenAdapter extends EngineAdapter {
-    readonly id = "hyperqwen";
-    readonly supports: {
-        docker: boolean;
-        local: boolean;
-    };
-    private readonly host;
-    constructor(host?: LifecycleHost);
-    parameters(): readonly ParameterSpec[];
-    modelRef(_config: Config): {
-        id: string;
-        name: string;
-    };
-    launchSignature(config?: Config): EngineLaunchSignature;
-    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
-    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, _options?: DeployOptions): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private port;
-    private profile;
-}
-/**
- * The llama.cpp docker image the adapter pulls and runs. The engineFork
- * platform config overrides the git source for a local build; the image stays
- * the upstream ggml artifact.
- */
-export declare const LLAMACPP_DOCKER_IMAGE = "ghcr.io/ggml-org/llama.cpp";
-/**
- * LlamaCppAdapter is the llama.cpp engine, both-capable like NInfer.
- * `renderLaunch` renders a local `llama-server` process or a `docker run` of the
- * ggml image from the same `LLAMACPP_PARAMETERS` surface; `deploy` builds the
- * engine in the engine directory (or pulls the image), downloads the GGUF model
- * into the model directory, and starts the engine; `healthCheck` polls the health
- * URL; `stop` signals the tracked process and stops the named container.
- */
-export declare class LlamaCppAdapter extends EngineAdapter {
-    readonly id = "llamacpp";
-    readonly supports: {
-        docker: boolean;
-        local: boolean;
-    };
-    private readonly host;
-    private readonly children;
-    constructor(host?: LifecycleHost);
-    parameters(): readonly ParameterSpec[];
-    modelRef(config: Config): {
-        id: string;
-        name: string;
-    };
-    launchSignature(config?: Config): EngineLaunchSignature;
-    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
-    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private buildMode;
-    private port;
-    private planKey;
-    private downloadModel;
-}
-/**
- * The Strata docker image the adapter pulls and runs. Strata is the
- * placeholder engine: the image and the parameter data land when the engine
- * is available, and the adapter renders a bare docker plan until then.
- */
-export declare const STRATA_DOCKER_IMAGE = "ghcr.io/strata/strata";
-/**
- * StrataAdapter is the placeholder docker-only engine. `renderLaunch` renders
- * a `docker run` of the Strata image (no spec surface yet, so no flags);
- * `deploy` pulls the image and starts the container; `healthCheck` polls the
- * health URL; `stop` stops the named container. The parameter surface and the
- * per-model data land with the engine, as data edits, never an adapter rewire.
- */
-export declare class StrataAdapter extends EngineAdapter {
-    readonly id = "strata";
-    readonly supports: {
-        docker: boolean;
-        local: boolean;
-    };
-    private readonly host;
-    private readonly children;
-    constructor(host?: LifecycleHost);
-    parameters(): readonly ParameterSpec[];
-    modelRef(_config: Config): {
-        id: string;
-        name: string;
-    };
-    launchSignature(config?: Config): EngineLaunchSignature;
-    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
-    deploy(plan: LaunchPlan, _platform?: EnginePlatformConfig, onProgress?: LaunchProgress, _options?: DeployOptions): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private port;
-    private planKey;
-}
-/**
- * InfernixAdapter is the local-only engine for Infernix, the C++/CUDA fork
- * of NInfer (https://github.com/wallawalla47/infernix) tuned for Qwen models
- * on a single RTX 50-series GPU. `renderLaunch` renders a local
- * `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
- * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
- * onto the argv only for this engine); `deploy` builds the engine in the
- * engine directory (the engine's own cmake preset), downloads the model
- * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
- * the model directory, and starts the engine; `healthCheck` polls the health
- * URL; `stop` signals the tracked process. The engine ships no docker image,
- * so the adapter supports the local build mode only.
+ * delay waits `ms` milliseconds. The health polls use it between attempts; a
+ * poll interval of 0 skips the wait, which the tests use to run the loop
+ * without a real sleep.
  */
-export declare class InfernixAdapter extends EngineAdapter {
-    readonly id = "infernix";
-    readonly supports: {
-        docker: boolean;
-        local: boolean;
-    };
-    private readonly host;
-    private readonly children;
-    constructor(host?: LifecycleHost);
-    parameters(): readonly ParameterSpec[];
-    modelRef(config: Config): {
-        id: string;
-        name: string;
-    };
-    launchSignature(config?: Config): EngineLaunchSignature;
-    renderLaunch(config: Config, _hw: HardwareProfile): LaunchPlan;
-    deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
-    healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    stop(plan: LaunchPlan): Promise<void>;
-    private port;
-    private planKey;
-    private downloadModel;
-}
+export declare function delay(ms: number): Promise<void>;
 //# sourceMappingURL=adapters.d.ts.map