dsh-plugin-local-infer 0.1.3 → 0.1.4

package/packages/providers/lib/engines/{strataAdapter.js → strata/strataAdapter.js}

@@ -13,13 +13,16 @@
  * queries the running engine's model endpoint through the terminal for the id
  * it actually loaded (family and size sized to the host), so the registrar
  * publishes the served model, not a placeholder.
- * @module dsh-plugin-local-infer/providers/engines/strataAdapter
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataAdapter
  */
 import { join } from 'node:path';
-import { EngineAdapter } from '../../../core/lib/index.js';
-import { customArgEnv, customArgFlags, delay, envFromSpecs, flagsFromSpecs, nodeLifecycleHost, trackChild, } from "../adapters.js";
-import { syncAndRebuildEngine } from "../acquire.js";
-import { STRATA_PARAMETERS, strataModelKey } from "./strata.js";
+import { EngineAdapter, autoRebuildEnabled } from '../../../../core/lib/index.js';
+import { HEALTH_POLL_DEFAULT_MS, HEALTH_POLL_MAX_ATTEMPTS, auditRun, customArgEnv, customArgFlags, delay, envFromSpecs, flagsFromSpecs, logHealthPoll, nodeLifecycleHost, stopProcessPlan, trackChild, } from "../../adapters.js";
+import { syncEngineForDeploy } from "../../acquire.js";
+import { STRATA_PARAMETERS, strataDefaults, strataModelKey, } from "./strata.js";
+import { strataLinuxSourceLaunch } from "./strataLinux.js";
+import { strataMacOSSourceLaunch } from "./strataMacOS.js";
+import { strataWindowsSourceLaunch } from "./strataWindows.js";
 /**
  * The Strata docker image the adapter pulls and runs. The image is the
  * upstream GitHub Container Registry artifact for the newest release's CUDA 13
@@ -34,6 +37,17 @@ export const STRATA_DOCKER_IMAGE = 'ghcr.io/niko1221/strata:latest-cuda13';
  * docs/AI_SETUP.md step 2 (Linux and Mac; Windows uses the PowerShell twin).
  */
 export const STRATA_BINARY_INSTALL = 'curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh';
+/**
+ * The source-build wrapper is OS-specific (setup.sh on Linux/Mac,
+ * START-HERE.bat on Windows), so the launch argv comes from the host OS's
+ * launch function. The adapter's renderLaunch reads this map by the hardware
+ * profile's os, keeping the per-OS command in its own OS file.
+ */
+const STRATA_SOURCE_LAUNCH = {
+    linux: strataLinuxSourceLaunch,
+    macos: strataMacOSSourceLaunch,
+    windows: strataWindowsSourceLaunch,
+};
 /**
  * strataPreReadyState reads the phase the strata process is in from the tail of
  * its accumulated output. The Terminal downloads the engine and the model files
@@ -201,6 +215,7 @@ export class StrataAdapter extends EngineAdapter {
                 ...(modelId !== undefined ? { modelId } : {}),
                 port,
                 healthUrl: `http://127.0.0.1:${port}/health`,
+                os: _hw.os,
             };
         }
         if (mode === 'binary') {
@@ -225,50 +240,48 @@ export class StrataAdapter extends EngineAdapter {
                 ...(modelId !== undefined ? { modelId } : {}),
                 port,
                 healthUrl: `http://127.0.0.1:${port}/health`,
+                os: _hw.os,
             };
         }
-        // The source build: run setup.sh with the model. It reuses the engine the
-        // Get step built (the acquisition build step), downloads the named model,
-        // and starts the engine. Running setup.sh (rather than a pre-written
-        // run-<model>.sh start script) is model-aware and self-contained, so the
+        // The source build: run the OS wrapper (setup.sh on Linux/Mac,
+        // START-HERE.bat on Windows) with the model. It reuses the engine the Get
+        // step built (the acquisition build step), downloads the named model, and
+        // starts the engine. Running the wrapper (rather than a pre-written
+        // run-<model> start script) is model-aware and self-contained, so the
         // launch does not depend on the build step having written a script for this
-        // exact model. The deploy step resolves setup.sh to an absolute path in the
-        // checkout before spawning.
-        const family = typeof config.family === 'string' && config.family !== '' ? config.family : 'qwen';
-        const vision = typeof config.vision === 'string' && config.vision !== '' ? config.vision : 'on';
-        const context = typeof config.context === 'string' && config.context !== '' ? config.context : undefined;
-        // setup.sh's --vision takes yes|no|gpu|cpu; the surface's on|off maps onto
-        // it (gpu and cpu pass through).
-        const visionFlag = vision === 'on' ? 'yes' : vision === 'off' ? 'no' : vision;
+        // exact model. The deploy step resolves the wrapper to an absolute path in
+        // the checkout before spawning.
+        // The source-build wrapper is OS-specific (setup.sh on Linux/Mac,
+        // START-HERE.bat on Windows), so the argv comes from the host OS's launch
+        // function. The config reads (family, vision, context) are OS-agnostic and
+        // resolve their defaults from the parameter surface, so the defaults have
+        // one home.
+        const { family, vision, context } = strataDefaults(config);
+        const sourceLaunch = STRATA_SOURCE_LAUNCH[_hw.os];
         return {
             engineId: this.id,
             kind: 'process',
-            argv: [
-                'setup.sh',
-                '--yes',
-                ...(model !== '' ? ['--model', model] : []),
-                ...(family !== 'qwen' ? ['--family', family] : []),
-                '--vision',
-                visionFlag,
-                ...(context !== undefined ? ['--context', context] : []),
-                '--port',
-                String(port),
-                ...customArgs,
-            ],
+            argv: sourceLaunch({ model, family, vision, context, port, customArgs }),
             env: {},
             ...(modelId !== undefined ? { modelId } : {}),
             port,
             healthUrl: `http://127.0.0.1:${port}/health`,
+            os: _hw.os,
         };
     }
     async deploy(plan, platform, onProgress, options) {
         if (plan.kind === 'docker') {
-            // The image pull is the docker build step: the card's button reads
-            // "Building..." for it.
-            onProgress?.('build');
-            const pull = await this.host.run(`docker pull ${STRATA_DOCKER_IMAGE}`);
-            if (!pull.ok) {
-                return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
+            // Auto Rebuild off (the card's checkbox): the image pull is skipped and
+            // the already-present image starts. The image pull is the docker build
+            // step: the card's button reads "Building..." for it, and its
+            // `$ <command>` line reaches the launch run's log sink before the child
+            // spawns.
+            if (autoRebuildEnabled(options?.autoRebuild)) {
+                onProgress?.('build');
+                const pull = await auditRun(this.host, `docker pull ${STRATA_DOCKER_IMAGE}`, options?.onLog);
+                if (!pull.ok) {
+                    return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
+                }
             }
             const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
             trackChild(this.children, this.planKey(plan), handle);
@@ -278,60 +291,61 @@ export class StrataAdapter extends EngineAdapter {
             const engineDir = platform?.engineDirectory;
             // The binary plan runs the strata command (on the PATH after the install
             // script), so its build step is the one-line install. The source-build
-            // plan runs setup.sh in the checkout, so its build step is the git sync
-            // plus the engine's own setup.sh (the acquisition build steps), and the
-            // launch resolves setup.sh to an absolute path in that checkout.
+            // plan runs the OS wrapper in the checkout, so its build step is the git
+            // sync plus the engine's own wrapper (the acquisition build steps), and
+            // the launch resolves the wrapper to an absolute path in that checkout.
             const isBinary = plan.argv?.[0] === 'strata';
             let buildLogs = '';
             if (isBinary) {
-                // The install script downloads the Terminal: the card's button reads
-                // "Downloading..." for it.
-                onProgress?.('download');
-                const install = await this.host.run(STRATA_BINARY_INSTALL);
-                if (!install.ok) {
-                    return { ok: false, detail: `strata install failed: ${install.detail ?? 'unknown'}` };
+                // Auto Rebuild off (the card's checkbox): the install is skipped and
+                // the already-installed strata command starts. The install script
+                // downloads the Terminal: the card's button reads "Downloading..."
+                // for it, and its `$ <command>` line reaches the launch run's log
+                // sink before the child spawns.
+                if (autoRebuildEnabled(options?.autoRebuild)) {
+                    onProgress?.('download');
+                    const install = await auditRun(this.host, STRATA_BINARY_INSTALL, options?.onLog);
+                    if (!install.ok) {
+                        return { ok: false, detail: `strata install failed: ${install.detail ?? 'unknown'}` };
+                    }
                 }
             }
             else {
-                // The source build needs the checkout directory to resolve setup.sh;
-                // without it the launch cannot find the engine.
+                // The source build needs the checkout directory to resolve the OS
+                // wrapper; without it the launch cannot find the engine.
                 if (engineDir === undefined) {
                     return {
                         ok: false,
-                        detail: 'the source build needs an engine directory (the Get step checkout) to run setup.sh',
+                        detail: 'the source build needs an engine directory (the Get step checkout) to run the OS wrapper',
                     };
                 }
-                if (options?.autoRebuild !== false) {
-                    onProgress?.('download');
-                    const sync = await syncAndRebuildEngine(this.host, {
+                if (autoRebuildEnabled(options?.autoRebuild)) {
+                    // The conditional rebuild fetches the checkout, prices it against the
+                    // remote branch, and rebuilds only when it is behind (or a fresh
+                    // clone). The decision, the build command, and its output are
+                    // captured into buildLogs and threaded to the card's Logs section.
+                    const sync = await syncEngineForDeploy(this.host, {
                         engineId: this.id,
                         directory: engineDir,
-                        ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
-                        ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
-                        ...(platform?.buildCommands !== undefined
-                            ? { buildCommands: platform.buildCommands }
-                            : {}),
-                        // Report the build phase the moment the build steps start, so the
-                        // card's button reads "Building..." while the build is in flight.
-                        onBuildStart: () => onProgress?.('build'),
-                    }, () => { });
-                    buildLogs = sync.logs;
+                        ...(platform !== undefined ? { platform } : {}),
+                        ...(options !== undefined ? { options } : {}),
+                        // The host OS the build steps pick for: a Windows host reads the
+                        // engine's Windows build steps when the user carries no build-
+                        // command override.
+                        ...(plan.os !== undefined ? { os: plan.os } : {}),
+                        ...(onProgress !== undefined ? { onProgress } : {}),
+                    });
+                    buildLogs = sync.buildLogs;
                     if (!sync.ok) {
                         return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
                     }
-                    // The build output reads as a fresh Logs section: a "Building..."
-                    // separator leads the build decision and output, the same line the
-                    // card writes when the build step event lands.
-                    if (sync.rebuilt && buildLogs !== '') {
-                        buildLogs = `--- Building...\n${buildLogs}`;
-                    }
                 }
             }
             const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
-            // The source-build plan names setup.sh relative to the checkout; resolve
-            // it to an absolute path so spawn finds it (spawn resolves a bare name
-            // against PATH, not the cwd). The binary plan's strata is on the PATH, so
-            // it spawns as-is.
+            // The source-build plan names the OS wrapper relative to the checkout;
+            // resolve it to an absolute path so spawn finds it (spawn resolves a bare
+            // name against PATH, not the cwd). The binary plan's strata is on the
+            // PATH, so it spawns as-is.
             const argv = plan.argv ?? [];
             const spawnArgv = !isBinary && engineDir !== undefined
                 ? [join(engineDir, argv[0] ?? 'setup.sh'), ...argv.slice(1)]
@@ -351,62 +365,85 @@ export class StrataAdapter extends EngineAdapter {
         // reports the start phase: a 200 is ready, a process that ended before
         // readiness is failed, and a process still fetching its files after the
         // attempt cap is downloading (in progress, not a failure) so the card
-        // re-polls instead of showing a broken launch.
-        const pollMs = options?.pollMs ?? 1000;
-        const maxAttempts = options?.maxAttempts ?? 120;
-        let last = { status: 0, ok: false };
-        let lastPreReady = null;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            last = await this.host.fetch(plan.healthUrl);
-            if (last.status === 200) {
-                return { healthy: true, status: 200, state: 'ready' };
-            }
-            // A running tracked process reports its start phase from its output. A
-            // missing handle (no deploy tracked one, or the process already ended)
-            // falls through to the plain poll: the health URL stays down, so the
-            // loop times out and reads the start as failed.
+        // re-polls instead of showing a broken launch. The shared logHealthPoll
+        // wrap carries the URL-query rule (one `> GET` line ahead of the settled
+        // verdict, retries silent).
+        return logHealthPoll(options?.onLog, plan.healthUrl, async () => {
+            const pollMs = options?.pollMs ?? HEALTH_POLL_DEFAULT_MS;
+            const maxAttempts = options?.maxAttempts ?? HEALTH_POLL_MAX_ATTEMPTS;
+            // The tracked handle is read before the loop: trackChild drops the map
+            // entry when the child ends, so a late read would miss the exit state
+            // the early-exit check needs.
             const handle = this.children.get(this.planKey(plan));
-            if (handle !== undefined) {
-                lastPreReady = strataPreReadyState(handle.logs ?? '');
+            let last = { status: 0, ok: false };
+            let lastPreReady = null;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                // The state read runs before the fetch: a child that settled (a crash,
+                // a pkill, or a spawn failure) will never report 200, so the poll
+                // ends here with a failed result instead of the full attempt cap.
+                if (handle?.hasExited?.() === true) {
+                    return {
+                        healthy: false,
+                        status: last.status,
+                        state: 'failed',
+                        detail: 'the engine process exited before it reported ready',
+                    };
+                }
+                last = await this.host.fetch(plan.healthUrl);
+                if (last.status === 200) {
+                    return { healthy: true, status: 200, state: 'ready' };
+                }
+                // A running tracked process reports its start phase from its output. A
+                // missing handle (no deploy tracked one, or the process already ended)
+                // falls through to the plain poll: the health URL stays down, so the
+                // loop times out and reads the start as failed.
+                if (handle !== undefined) {
+                    lastPreReady = strataPreReadyState(handle.logs ?? '');
+                }
+                if (pollMs > 0 && attempt < maxAttempts) {
+                    await delay(pollMs);
+                }
             }
-            if (pollMs > 0 && attempt < maxAttempts) {
-                await delay(pollMs);
+            // The engine did not report ready within the attempt cap. If it was still
+            // downloading its files, read the start as in progress (downloading): the
+            // download is not a broken launch, and the card re-polls until the engine
+            // reports ready. If the download was done and the engine was starting,
+            // read the start as failed (a stuck start timed out).
+            if (lastPreReady === 'downloading') {
+                return {
+                    healthy: false,
+                    status: last.status,
+                    state: 'downloading',
+                    detail: 'the engine is still downloading its model files',
+                };
             }
-        }
-        // The engine did not report ready within the attempt cap. If it was still
-        // downloading its files, read the start as in progress (downloading): the
-        // download is not a broken launch, and the card re-polls until the engine
-        // reports ready. If the download was done and the engine was starting,
-        // read the start as failed (a stuck start timed out).
-        if (lastPreReady === 'downloading') {
             return {
                 healthy: false,
                 status: last.status,
-                state: 'downloading',
-                detail: 'the engine is still downloading its model files',
+                state: 'failed',
+                detail: `health check did not return 200 within ${maxAttempts} attempts`,
             };
-        }
-        return {
-            healthy: false,
-            status: last.status,
-            state: 'failed',
-            detail: `health check did not return 200 within ${maxAttempts} attempts`,
-        };
+        });
     }
-    async stop(plan) {
+    async stop(plan, log) {
         if (plan.kind === 'docker' && plan.containerName !== undefined) {
-            await this.host.run(`docker stop ${plan.containerName}`);
+            await auditRun(this.host, `docker stop ${plan.containerName}`, log);
         }
         // The binary plan stops through the strata command; the source-build plan
         // has no strata command, so it stops by signalling the tracked process.
         if (plan.kind === 'process' && plan.argv?.[0] === 'strata') {
-            await this.host.run('strata launch --stop');
+            await auditRun(this.host, 'strata launch --stop', log);
         }
         const handle = this.children.get(this.planKey(plan));
         if (handle !== undefined) {
             handle.kill();
             this.children.delete(this.planKey(plan));
+            return;
         }
+        // No tracked child (an engine a DSH restart re-adopted): signal the pid
+        // the stored launch record stamped on the plan, so the stop reaches a
+        // process this adapter instance did not spawn.
+        await stopProcessPlan(this.host, plan, log);
     }
     buildMode(config) {
         const mode = config.buildMode;
@@ -418,10 +455,9 @@ export class StrataAdapter extends EngineAdapter {
         return 'binary';
     }
     port(config) {
+        // 8080 is the port the strata launch CLI binds by default, so a bare
+        // config launches on it.
         return typeof config.port === 'number' ? config.port : 8080;
     }
-    planKey(plan) {
-        return `${plan.engineId}:${plan.port}`;
-    }
 }
-//# sourceMappingURL=strataAdapter.js.map
+//# sourceMappingURL=strataAdapter.js.map

package/packages/providers/lib/engines/strata/strataArch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Arch Linux build profile. Arch builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataArch
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_ARCH: EngineOsProfile;
+//# sourceMappingURL=strataArch.d.ts.map

package/packages/providers/lib/engines/strata/strataArch.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Arch Linux build profile. Arch builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataArch
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_ARCH = STRATA_LINUX;
+//# sourceMappingURL=strataArch.js.map

package/packages/providers/lib/engines/strata/strataDebian.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Debian build profile. Debian builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataDebian
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_DEBIAN: EngineOsProfile;
+//# sourceMappingURL=strataDebian.d.ts.map

package/packages/providers/lib/engines/strata/strataDebian.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Debian build profile. Debian builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataDebian
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_DEBIAN = STRATA_LINUX;
+//# sourceMappingURL=strataDebian.js.map

package/packages/providers/lib/engines/strata/strataFedora.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Fedora build profile. Fedora builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_FEDORA: EngineOsProfile;
+//# sourceMappingURL=strataFedora.d.ts.map

package/packages/providers/lib/engines/strata/strataFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Fedora build profile. Fedora builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataFedora
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_FEDORA = STRATA_LINUX;
+//# sourceMappingURL=strataFedora.js.map

package/packages/providers/lib/engines/strata/strataLinux.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The Strata shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Strata through the engine's own setup.sh: the README's
+ * Build-from-source route, which downloads what it needs and installs the
+ * `strata` Terminal to the path. `--yes` takes the recommended answer to every
+ * question and `--no-start` builds and installs without starting the server,
+ * which the adapter's launch step then does. There is no build directory,
+ * because setup.sh installs the binary to the path. The distro profiles reuse
+ * this profile.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataLinux
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import { type StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_LINUX: EngineOsProfile;
+/**
+ * strataLinuxSourceLaunch renders the source-build launch argv for the Linux
+ * route: the engine's own setup.sh with --yes (unattended) and the resolved
+ * model, family, vision, context, and port. macOS reuses this route.
+ */
+export declare function strataLinuxSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataLinux.d.ts.map

package/packages/providers/lib/engines/strata/strataLinux.js

@@ -0,0 +1,30 @@
+/**
+ * The Strata shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Strata through the engine's own setup.sh: the README's
+ * Build-from-source route, which downloads what it needs and installs the
+ * `strata` Terminal to the path. `--yes` takes the recommended answer to every
+ * question and `--no-start` builds and installs without starting the server,
+ * which the adapter's launch step then does. There is no build directory,
+ * because setup.sh installs the binary to the path. The distro profiles reuse
+ * this profile.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataLinux
+ */
+import { strataSourceLaunchArgs } from "./strata.js";
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const STRATA_LINUX = {
+    buildSteps: ['cd {dir} && ./setup.sh --yes --no-start'],
+    binary: 'strata',
+    // The Strata source build git-clones the repo and runs setup.sh, which
+    // downloads what it needs; the only host deps are git (the clone) and curl
+    // (the model download).
+    deps: [SYSTEM_DEPS.git, SYSTEM_DEPS.curl],
+};
+/**
+ * strataLinuxSourceLaunch renders the source-build launch argv for the Linux
+ * route: the engine's own setup.sh with --yes (unattended) and the resolved
+ * model, family, vision, context, and port. macOS reuses this route.
+ */
+export function strataLinuxSourceLaunch(args) {
+    return strataSourceLaunchArgs('setup.sh', args);
+}
+//# sourceMappingURL=strataLinux.js.map

package/packages/providers/lib/engines/strata/strataMacOS.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The Strata macOS build profile. macOS builds Strata through the engine's own
+ * setup.sh, the same route as Linux (the README's setup walks both), so this
+ * profile reuses the shared Linux build steps; the binary keeps its plain
+ * name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataMacOS
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import type { StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_MACOS: EngineOsProfile;
+/**
+ * strataMacOSSourceLaunch reuses the Linux source-build launch: macOS builds
+ * through the same setup.sh route, so the argv is identical.
+ */
+export declare function strataMacOSSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataMacOS.d.ts.map

package/packages/providers/lib/engines/strata/strataMacOS.js

@@ -0,0 +1,17 @@
+/**
+ * The Strata macOS build profile. macOS builds Strata through the engine's own
+ * setup.sh, the same route as Linux (the README's setup walks both), so this
+ * profile reuses the shared Linux build steps; the binary keeps its plain
+ * name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataMacOS
+ */
+import { STRATA_LINUX, strataLinuxSourceLaunch } from "./strataLinux.js";
+export const STRATA_MACOS = STRATA_LINUX;
+/**
+ * strataMacOSSourceLaunch reuses the Linux source-build launch: macOS builds
+ * through the same setup.sh route, so the argv is identical.
+ */
+export function strataMacOSSourceLaunch(args) {
+    return strataLinuxSourceLaunch(args);
+}
+//# sourceMappingURL=strataMacOS.js.map

package/packages/providers/lib/engines/strata/strataWindows.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The Strata Windows build profile. The Windows source route is the engine's
+ * own START-HERE.bat wrapper (docs/SOURCE_INSTALL.md, From source: Windows),
+ * not the Linux setup.sh. `--yes` accepts the recommended answer to every
+ * question, so the step runs unattended. The wrapper acquires a ready-made
+ * engine when one fits the PC, and compiles one when it does not: the
+ * compile needs the Visual Studio 2022 Build Tools with the C++ workload
+ * (the sources are C++20, so VS2019 is too old). When setup cannot find the
+ * toolchain, point STRATA_VCVARS at vcvars64.bat before running. The build
+ * keeps its dependencies and products in the source install and writes the
+ * launch scripts (run-<model>.bat) and run configs (strata-<model>.json)
+ * into the checkout, so the profile carries no build directory. Updates run
+ * through UPDATE.bat.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataWindows
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import { type StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_WINDOWS: EngineOsProfile;
+/**
+ * strataWindowsSourceLaunch renders the source-build launch argv for the
+ * Windows route: the engine's own START-HERE.bat wrapper with --yes
+ * (unattended) and the resolved model, family, vision, context, and port. The
+ * wrapper acquires a ready-made engine when one fits the PC, and compiles one
+ * (the Visual Studio 2022 C++ toolchain) when it does not.
+ */
+export declare function strataWindowsSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataWindows.d.ts.map

package/packages/providers/lib/engines/strata/strataWindows.js

@@ -0,0 +1,37 @@
+/**
+ * The Strata Windows build profile. The Windows source route is the engine's
+ * own START-HERE.bat wrapper (docs/SOURCE_INSTALL.md, From source: Windows),
+ * not the Linux setup.sh. `--yes` accepts the recommended answer to every
+ * question, so the step runs unattended. The wrapper acquires a ready-made
+ * engine when one fits the PC, and compiles one when it does not: the
+ * compile needs the Visual Studio 2022 Build Tools with the C++ workload
+ * (the sources are C++20, so VS2019 is too old). When setup cannot find the
+ * toolchain, point STRATA_VCVARS at vcvars64.bat before running. The build
+ * keeps its dependencies and products in the source install and writes the
+ * launch scripts (run-<model>.bat) and run configs (strata-<model>.json)
+ * into the checkout, so the profile carries no build directory. Updates run
+ * through UPDATE.bat.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataWindows
+ */
+import { strataSourceLaunchArgs } from "./strata.js";
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const STRATA_WINDOWS = {
+    buildSteps: ['cd {dir} && .\\START-HERE.bat --yes'],
+    // The engine command is the strata Terminal on every platform (a
+    // PowerShell command on Windows), so the name stays plain.
+    binary: 'strata',
+    // The Windows source route is the engine's own START-HERE.bat wrapper; the
+    // host deps are the same git-plus-curl list as the Linux route.
+    deps: [SYSTEM_DEPS.git, SYSTEM_DEPS.curl],
+};
+/**
+ * strataWindowsSourceLaunch renders the source-build launch argv for the
+ * Windows route: the engine's own START-HERE.bat wrapper with --yes
+ * (unattended) and the resolved model, family, vision, context, and port. The
+ * wrapper acquires a ready-made engine when one fits the PC, and compiles one
+ * (the Visual Studio 2022 C++ toolchain) when it does not.
+ */
+export function strataWindowsSourceLaunch(args) {
+    return strataSourceLaunchArgs('START-HERE.bat', args);
+}
+//# sourceMappingURL=strataWindows.js.map

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

@@ -20,10 +20,12 @@ export interface EngineInfo {
 }
 /**
  * The engines the Web card offers, in the order the card lists them. NInfer,
- * Hyper-Qwen, Infernix, llama.cpp, and Strata all carry parameter surfaces
- * (llama.cpp's is the specified set the plan names, verified when the binary
- * lands); Strata's surface is the `strata launch` flags and it supports all
- * three build modes (docker, source build, and the binary install).
+ * Hyper-Qwen, Infernix, llama.cpp, Strata, and Basalt all carry parameter
+ * surfaces (llama.cpp's is the specified set the plan names, verified when the
+ * binary lands); Strata's surface is the `strata launch` flags and it supports
+ * all three build modes (docker, source build, and the binary install);
+ * Basalt's surface is the `basalt_config.json` settings and it is local-build
+ * only (the C++/CUDA engine ships no container image).
  */
 export declare const ENGINES: readonly EngineInfo[];
-//# sourceMappingURL=engines.d.ts.map
+//# sourceMappingURL=engines.d.ts.map