dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/providers/lib/engines/ninfer/ninferAdapter.js

@@ -0,0 +1,392 @@
+/**
+ * The NInfer engine adapter. 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.
+ * 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.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferAdapter
+ */
+import { basename, dirname, join } from 'node:path';
+import { CHAT_TEMPLATE_FILE, EngineAdapter, autoRebuildEnabled, chatTemplateArtifactPath, chatTemplatePresent, hfChatTemplateCommand, hfDownloadCommand, hfHubCacheDirectory, hubCacheSnapshotFilePath, modelArtifactPresent, modelDownloadTarget, } from '../../../../core/lib/index.js';
+import { auditRun, customArgFlags, flagsFromSpecs, nodeLifecycleHost, pollHealth, resolveLaunchArgv, stopProcessPlan, trackChild, } from "../../adapters.js";
+import { syncEngineForDeploy } from "../../acquire.js";
+import { NINFER_PARAMETERS } from "./ninfer.js";
+import { ninferLinuxBinary } from "./ninferLinux.js";
+import { ninferMacOSBinary } from "./ninferMacOS.js";
+import { ninferWindowsBinary } from "./ninferWindows.js";
+/**
+ * The NInfer engine binary is OS-specific (the .exe on Windows, where the
+ * vcpkg build-native route writes the Release binary), so the launch binary
+ * comes from the host OS's binary function. The adapter's renderLaunch reads
+ * this map by the hardware profile's os, keeping the per-OS name in its own OS
+ * file.
+ */
+const NINFER_BINARY = {
+    linux: ninferLinuxBinary,
+    macos: ninferMacOSBinary,
+    windows: ninferWindowsBinary,
+};
+/**
+ * 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 const NINFER_MODEL_ARTIFACTS = {
+    'qwen3-27b': {
+        file: 'qwen3_8_27b_nvfp4.ninfer',
+        repo: 'neroued/Qwen3.8-27B-nvfp4-NInfer',
+        modelId: 'Qwen3.8-27B',
+    },
+    // The Swift 1.5 ablated 27B the local launcher bootstraps: the nvfp4-full
+    // DFlash2 artifact the qwen-ninfer script serves. It reuses the 27B model id
+    // the engine advertises, so a chat turn routes to the same alias.
+    'qwen3-27b-swift15': {
+        file: 'qwen3_8_27b_swift15abl_nvfp4full-dflash2.ninfer',
+        repo: 'kaushikvira/Qwen3.8-27B-swift15-uncensored-ajgazin-nvfp4full-dflash2-NInfer-v3',
+        modelId: 'Qwen3.8-27B',
+    },
+    'qwen3-35b': {
+        file: 'qwen3_8_35b_a3b.ninfer',
+        repo: 'Neroued/Qwen3.8-35B-A3B-NInfer',
+        modelId: 'Qwen3.8-35B-A3B',
+    },
+    'qwen36-35b': {
+        file: 'qwen3_6_35b_a3b.ninfer',
+        repo: 'neroued/Qwen3.6-35B-A3B-NInfer',
+        modelId: 'Qwen3.6-35B-A3B',
+    },
+};
+/**
+ * artifactFor resolves the artifact a model id deploys. An id no entry names
+ * falls back to the 27B artifact, so a bare config always renders a plan.
+ */
+function artifactFor(modelId) {
+    const artifact = modelId !== undefined ? NINFER_MODEL_ARTIFACTS[modelId] : undefined;
+    return artifact ?? NINFER_MODEL_ARTIFACTS['qwen3-27b'];
+}
+/**
+ * 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 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 class NInferAdapter extends EngineAdapter {
+    id = 'ninfer';
+    supports = { docker: true, local: true };
+    host;
+    children = new Map();
+    constructor(host = nodeLifecycleHost) {
+        super();
+        this.host = host;
+    }
+    parameters() {
+        return NINFER_PARAMETERS;
+    }
+    modelRef(config) {
+        // The id the engine advertises on its OpenAI endpoint is the artifact's
+        // --model-id alias, not the VramModel registry key the config names, so
+        // the registrar publishes the alias and a chat turn routes to it.
+        const artifact = artifactFor(typeof config.model === 'string' ? config.model : 'qwen3-27b');
+        return { id: artifact.modelId, name: artifact.modelId };
+    }
+    launchSignature(config = {}) {
+        // The local plan runs the ninfer-serve binary; the docker plan's host
+        // process is docker run of the ghcr image, so the image name is the
+        // command-line marker the reserve probe matches on.
+        const port = this.port(config);
+        if (this.buildMode(config) === 'docker') {
+            return { binary: NINFER_DOCKER_IMAGE, port };
+        }
+        return { binary: 'ninfer-serve', port };
+    }
+    renderLaunch(config, _hw) {
+        const port = this.port(config);
+        const modelId = typeof config.model === 'string' ? config.model : 'qwen3-27b';
+        const artifact = artifactFor(modelId);
+        // A model key that names a local artifact file (a directory-scanned
+        // model) overrides the artifact map's file, so a file the user has on
+        // disk launches as-is.
+        const file = modelId.endsWith('.ninfer') ? modelId : artifact.file;
+        const modelDirectory = typeof config.modelDirectory === 'string' ? config.modelDirectory : '';
+        const flags = flagsFromSpecs(NINFER_PARAMETERS, config);
+        if (this.buildMode(config) === 'docker') {
+            const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
+            const containerModelPath = `/models/${basename(file)}`;
+            const modelMount = modelDirectory === ''
+                ? `${file}:${containerModelPath}`
+                : `${dirname(modelPath)}:/models`;
+            const containerName = `ninfer-${port}`;
+            const customArgs = customArgFlags(config);
+            return {
+                engineId: this.id,
+                kind: 'docker',
+                argv: [
+                    'docker',
+                    'run',
+                    '--rm',
+                    '--gpus',
+                    'all',
+                    '--name',
+                    containerName,
+                    '-p',
+                    `127.0.0.1:${port}:8080`,
+                    '--ulimit',
+                    'memlock=-1',
+                    '-v',
+                    'ninfer-cache:/cache',
+                    '-v',
+                    modelMount,
+                    NINFER_DOCKER_IMAGE,
+                    'serve',
+                    containerModelPath,
+                    '--model-id',
+                    artifact.modelId,
+                    ...flags,
+                    ...customArgs,
+                ],
+                env: {},
+                containerName,
+                modelId,
+                ...(modelDirectory === '' ? {} : { modelDirectory }),
+                port,
+                healthUrl: `http://127.0.0.1:${port}/health`,
+                os: _hw.os,
+            };
+        }
+        // The hub-cache layout (the model directory is the plugin default)
+        // resolves the concrete snapshot file the engine reads; a user override
+        // keeps the flat model-directory path. A not-yet-downloaded model falls
+        // back to the bare file name, the same as the flat layout's missing-file
+        // case.
+        const modelPath = modelDirectory === ''
+            ? (hubCacheSnapshotFilePath(hfHubCacheDirectory(), artifact.repo, file) ?? file)
+            : join(modelDirectory, file);
+        const customArgs = customArgFlags(config);
+        return {
+            engineId: this.id,
+            kind: 'process',
+            argv: [
+                // The engine binary is OS-specific (the .exe on Windows), so the name
+                // comes from the host OS's binary function.
+                NINFER_BINARY[_hw.os](),
+                modelPath,
+                '--host',
+                '127.0.0.1',
+                '--port',
+                String(port),
+                '--model-id',
+                artifact.modelId,
+                ...flags,
+                ...customArgs,
+            ],
+            env: {},
+            modelId,
+            ...(modelDirectory === '' ? {} : { modelDirectory }),
+            port,
+            healthUrl: `http://127.0.0.1:${port}/health`,
+            os: _hw.os,
+        };
+    }
+    async deploy(plan, platform, onProgress, options) {
+        if (plan.kind === 'process') {
+            const engineDir = platform?.engineDirectory;
+            let buildLogs = '';
+            // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+            // rebuild) is skipped and the checkout launches as-is.
+            if (engineDir !== undefined && 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 !== undefined ? { platform } : {}),
+                    ...(options !== undefined ? { options } : {}),
+                    // The host OS the build steps pick for: a Windows host reads the
+                    // engine's Windows build steps (the vcpkg route) 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 };
+                }
+            }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            onProgress?.('download');
+            const download = await this.downloadModel(plan, options?.onLog);
+            if (!download.ok)
+                return withLogs(download);
+            // A chat template the user picked as an HF repo reference (the combo
+            // control's known choices) is not a path the engine can read, so the
+            // deploy step downloads it into the model directory and rewrites the
+            // --chat-template flag to the local file before the spawn.
+            onProgress?.('download');
+            const templateResult = await this.resolveChatTemplate(plan, options?.onLog);
+            if (!templateResult.ok)
+                return withLogs(templateResult);
+            // A relative launch path (the NInfer Windows build tree,
+            // build-windows\apps\Release\ninfer-serve.exe) is joined against the
+            // engine directory the spawn runs in, so the spawn resolves an absolute
+            // path. A bare name (the Linux and macOS binaries, resolved against the
+            // path) is left as-is.
+            const resolvedArgv = resolveLaunchArgv(engineDir, plan.argv);
+            // The plan is the launch record's argv source (launchRecordFromPlan reads
+            // it), and the re-link rule substring-matches every record argv token
+            // against the live command line, so the record must name the spawn, not
+            // the build-tree relative binary.
+            plan.argv = resolvedArgv;
+            const handle = this.host.spawn(resolvedArgv, plan.env ?? {}, engineDir);
+            trackChild(this.children, this.planKey(plan), handle);
+            return withLogs({ ok: true, handle });
+        }
+        if (plan.kind === 'docker') {
+            // 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 ${NINFER_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);
+            return { ok: true, handle };
+        }
+        // NInfer renders process and docker plans; a compose plan is a no-op.
+        return { ok: true };
+    }
+    async healthCheck(plan, options) {
+        // The tracked handle rides into the poll, so a child that exits (a
+        // crash) ends the poll early with a failed result.
+        return pollHealth(this.host, plan, options, this.children.get(this.planKey(plan)));
+    }
+    async stop(plan, log) {
+        if (plan.kind === 'docker' && plan.containerName !== undefined) {
+            await auditRun(this.host, `docker stop ${plan.containerName}`, 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) {
+        return config.buildMode === 'docker' ? 'docker' : 'local';
+    }
+    port(config) {
+        // 18020 is the port the ninfer-serve CLI binds by default, so a bare
+        // config launches on it.
+        return typeof config.port === 'number' ? config.port : 18020;
+    }
+    async downloadModel(plan, log) {
+        const artifact = plan.modelId !== undefined ? NINFER_MODEL_ARTIFACTS[plan.modelId] : undefined;
+        if (artifact === undefined)
+            return { ok: true };
+        // The hub-cache layout (no --local-dir) applies when the model directory is
+        // the plugin default; a user override keeps the flat --local-dir target.
+        const { baseDir, useHubCache } = modelDownloadTarget(plan.modelDirectory);
+        const entry = {
+            engineId: this.id,
+            modelId: plan.modelId ?? '',
+            label: artifact.modelId,
+            url: `https://huggingface.co/${artifact.repo}`,
+            file: artifact.file,
+        };
+        // A model the shared Get-steps routine already downloaded is on disk, so
+        // the deploy step skips the re-fetch and a launch after a Get does no
+        // duplicate download. Presence is the deterministic snapshot the resolved
+        // layout holds (modelArtifactPresent), never a bare blobs folder: a cache
+        // whose snapshot links are missing re-runs the cheap hf download, which
+        // reuses the blobs and writes the links.
+        if (modelArtifactPresent(entry, baseDir, useHubCache))
+            return { ok: true };
+        const download = await auditRun(this.host, hfDownloadCommand(entry, baseDir, useHubCache), log);
+        if (!download.ok) {
+            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
+        }
+        return { ok: true };
+    }
+    /**
+     * 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.
+     */
+    async resolveChatTemplate(plan, log) {
+        const argv = plan.argv;
+        if (argv === undefined)
+            return { ok: true };
+        const index = argv.indexOf('--chat-template');
+        if (index === -1)
+            return { ok: true };
+        const value = argv[index + 1];
+        if (value === undefined)
+            return { ok: true };
+        // An absolute path (a leading /) is already local; a value with no slash
+        // is a bare file name the engine resolves against its own directory.
+        if (value.startsWith('/') || !value.includes('/'))
+            return { ok: true };
+        // An HF repo reference: download the template file and point the flag at
+        // the local copy. The hub-cache layout (the model directory is the plugin
+        // default) resolves the concrete snapshot file path the hf CLI writes; a
+        // user override keeps the flat model-directory path. The flat path is
+        // built with join (the host's path module normalizes the separators), so
+        // the flag the engine reads resolves on Windows, Linux, and macOS alike.
+        const { baseDir, useHubCache } = modelDownloadTarget(plan.modelDirectory);
+        // The hub-cache branch resolves the deterministic snapshot file; the flat
+        // branch asks the shared presence predicate for the template join.
+        const resolvePath = () => useHubCache
+            ? hubCacheSnapshotFilePath(baseDir, value, CHAT_TEMPLATE_FILE)
+            : chatTemplatePresent(value, baseDir)
+                ? chatTemplateArtifactPath(baseDir)
+                : null;
+        let localPath = resolvePath();
+        // A template already on disk skips the re-fetch; the hf CLI is optional,
+        // so a download failure is reported but does not abort the launch.
+        if (localPath === null) {
+            const download = await auditRun(this.host, hfChatTemplateCommand(value, baseDir, useHubCache), log);
+            if (!download.ok) {
+                return {
+                    ok: false,
+                    detail: `chat template download failed: ${download.detail ?? 'unknown'}`,
+                };
+            }
+            localPath = resolvePath();
+            if (localPath === null) {
+                return { ok: false, detail: 'chat template download failed' };
+            }
+        }
+        argv[index + 1] = localPath;
+        return { ok: true };
+    }
+}
+//# sourceMappingURL=ninferAdapter.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Arch Linux build profile. Arch builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferArch
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_ARCH: EngineOsProfile;
+//# sourceMappingURL=ninferArch.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferArch.js

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Arch Linux build profile. Arch builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferArch
+ */
+import { NINFER_LINUX } from "./ninferLinux.js";
+export const NINFER_ARCH = NINFER_LINUX;
+//# sourceMappingURL=ninferArch.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Debian build profile. Debian builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferDebian
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_DEBIAN: EngineOsProfile;
+//# sourceMappingURL=ninferDebian.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferDebian.js

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Debian build profile. Debian builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferDebian
+ */
+import { NINFER_LINUX } from "./ninferLinux.js";
+export const NINFER_DEBIAN = NINFER_LINUX;
+//# sourceMappingURL=ninferDebian.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Fedora build profile. Fedora builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_FEDORA: EngineOsProfile;
+//# sourceMappingURL=ninferFedora.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The NInfer Fedora build profile. Fedora builds NInfer through the shared
+ * Linux route (cmake with the Ninja generator), so this profile reuses the
+ * shared Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferFedora
+ */
+import { NINFER_LINUX } from "./ninferLinux.js";
+export const NINFER_FEDORA = NINFER_LINUX;
+//# sourceMappingURL=ninferFedora.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * The NInfer shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds NInfer through this one route: cmake with the Ninja generator
+ * into the `build` directory, which is where the `ninfer-serve` binary lands.
+ * The distro profiles reuse this profile, so a distro carries no build steps of
+ * its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferLinux
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_LINUX: EngineOsProfile;
+/**
+ * ninferLinuxBinary returns the NInfer engine binary name on Linux: the plain
+ * `ninfer-serve` (no .exe). The name comes from the shared Linux profile, so
+ * the spelling has one home.
+ */
+export declare function ninferLinuxBinary(): string;
+//# sourceMappingURL=ninferLinux.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferLinux.js

@@ -0,0 +1,37 @@
+/**
+ * The NInfer shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds NInfer through this one route: cmake with the Ninja generator
+ * into the `build` directory, which is where the `ninfer-serve` binary lands.
+ * The distro profiles reuse this profile, so a distro carries no build steps of
+ * its own.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferLinux
+ */
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const NINFER_LINUX = {
+    buildSteps: [
+        'cmake -S {dir} -B {dir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && cmake --build {dir}/build -j',
+    ],
+    buildDir: 'build',
+    binary: 'ninfer-serve',
+    // The Linux local build needs the compile toolchain (cmake, ninja), the
+    // ffmpeg and curl dev libraries (pkg-config, ffmpeg, curl), the CUDA
+    // toolkit, and the hf CLI to download the model.
+    deps: [
+        SYSTEM_DEPS.cmake,
+        SYSTEM_DEPS.ninja,
+        SYSTEM_DEPS.pkgConfig,
+        SYSTEM_DEPS.ffmpeg,
+        SYSTEM_DEPS.curl,
+        SYSTEM_DEPS.cudaToolkit,
+        SYSTEM_DEPS.hfCli,
+    ],
+};
+/**
+ * ninferLinuxBinary returns the NInfer engine binary name on Linux: the plain
+ * `ninfer-serve` (no .exe). The name comes from the shared Linux profile, so
+ * the spelling has one home.
+ */
+export function ninferLinuxBinary() {
+    return NINFER_LINUX.binary ?? 'ninfer-serve';
+}
+//# sourceMappingURL=ninferLinux.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * The NInfer macOS build profile. macOS builds NInfer through the same cmake
+ * route as Linux, so this profile reuses the shared Linux build steps and
+ * build directory; the binary keeps its plain name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferMacOS
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_MACOS: EngineOsProfile;
+/**
+ * ninferMacOSBinary returns the NInfer engine binary name on macOS: the plain
+ * `ninfer-serve` (no .exe on macOS). The name comes from the shared Linux
+ * profile the macOS profile reuses, so the spelling has one home.
+ */
+export declare function ninferMacOSBinary(): string;
+//# sourceMappingURL=ninferMacOS.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferMacOS.js

@@ -0,0 +1,17 @@
+/**
+ * The NInfer macOS build profile. macOS builds NInfer through the same cmake
+ * route as Linux, so this profile reuses the shared Linux build steps and
+ * build directory; the binary keeps its plain name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferMacOS
+ */
+import { NINFER_LINUX } from "./ninferLinux.js";
+export const NINFER_MACOS = NINFER_LINUX;
+/**
+ * ninferMacOSBinary returns the NInfer engine binary name on macOS: the plain
+ * `ninfer-serve` (no .exe on macOS). The name comes from the shared Linux
+ * profile the macOS profile reuses, so the spelling has one home.
+ */
+export function ninferMacOSBinary() {
+    return NINFER_MACOS.binary ?? 'ninfer-serve';
+}
+//# sourceMappingURL=ninferMacOS.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * The NInfer Windows build profile. The Windows route is the ninfer-all fork's
+ * vcpkg build: the manifest pulls the dev libraries, then the engine's own
+ * build-native.bat configures and builds. The step cds into the checkout first
+ * (the {dir} placeholder), because vcpkg install and the relative script path
+ * both resolve against the checkout root.
+ *
+ * The build leaves the engine binary in the Windows build tree, not the Linux
+ * build directory: the vcpkg route writes ninfer-serve.exe into
+ * build-windows\apps\Release, so the launch step reads the binary from that
+ * directory, not from the shared Linux build directory. The launch binary is
+ * the path relative to the checkout root (the engine directory the spawn runs
+ * in), so the spawn resolves it against the default or override engine dir.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferWindows
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const NINFER_WINDOWS: EngineOsProfile;
+/**
+ * ninferWindowsBinary returns the NInfer launch binary on Windows: the path
+ * relative to the checkout root (the engine directory the spawn runs in) where
+ * the vcpkg build-native route writes the Release binary,
+ * `build-windows/apps/Release/ninfer-serve.exe`. The directory and the .exe
+ * name both come from the Windows profile, so the build tree and the spelling
+ * have one home. `join` keeps the result cross-platform: the host's path module
+ * normalizes the separators, so the spawn resolves it on Windows, Linux, and
+ * macOS alike.
+ */
+export declare function ninferWindowsBinary(): string;
+//# sourceMappingURL=ninferWindows.d.ts.map

package/packages/providers/lib/engines/ninfer/ninferWindows.js

@@ -0,0 +1,59 @@
+/**
+ * The NInfer Windows build profile. The Windows route is the ninfer-all fork's
+ * vcpkg build: the manifest pulls the dev libraries, then the engine's own
+ * build-native.bat configures and builds. The step cds into the checkout first
+ * (the {dir} placeholder), because vcpkg install and the relative script path
+ * both resolve against the checkout root.
+ *
+ * The build leaves the engine binary in the Windows build tree, not the Linux
+ * build directory: the vcpkg route writes ninfer-serve.exe into
+ * build-windows\apps\Release, so the launch step reads the binary from that
+ * directory, not from the shared Linux build directory. The launch binary is
+ * the path relative to the checkout root (the engine directory the spawn runs
+ * in), so the spawn resolves it against the default or override engine dir.
+ * @module dsh-plugin-local-infer/providers/engines/ninfer/ninferWindows
+ */
+import { join } from 'node:path';
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const NINFER_WINDOWS = {
+    buildSteps: [
+        '$env:PATH="C:\\Program Files\\Microsoft Visual Studio\\18\\Community\\VC\\vcpkg;$env:PATH"; $env:NINFER_VCPKG_ROOT="C:\\Program Files\\Microsoft Visual Studio\\18\\Community\\VC\\vcpkg"; cd {dir} && vcpkg install && .\\scripts\\build-native.bat configure && .\\scripts\\build-native.bat build && .\\scripts\\build-native.bat build',
+    ],
+    // The vcpkg build-native route writes the Release binary into the Windows
+    // build tree, not the Linux build directory the shared route uses. The
+    // separators are forward slashes (valid on every platform) so the directory
+    // joins cross-platform; the host's path module normalizes them on use.
+    buildDir: 'build-windows/apps/Release',
+    binary: 'ninfer-serve.exe',
+    // pwsh.exe (PowerShell 7+) is the modern shell the vcpkg build tooling
+    // expects; the legacy powershell.exe (Windows PowerShell 5.1) lacks it.
+    shell: 'pwsh.exe',
+    // The Windows local build is the vcpkg route: the winget toolchain (CMake,
+    // Ninja, the MSVC compiler, the CUDA toolkit) plus the hf CLI and git. The
+    // vcpkg manifest pulls the ffmpeg and curl dev libraries, so the Linux
+    // pkg-config/ffmpeg/curl deps do not ride the Windows list.
+    deps: [
+        SYSTEM_DEPS.cmake,
+        SYSTEM_DEPS.ninja,
+        SYSTEM_DEPS.visualStudio,
+        SYSTEM_DEPS.cudaToolkit,
+        SYSTEM_DEPS.hfCli,
+        SYSTEM_DEPS.git,
+    ],
+};
+/**
+ * ninferWindowsBinary returns the NInfer launch binary on Windows: the path
+ * relative to the checkout root (the engine directory the spawn runs in) where
+ * the vcpkg build-native route writes the Release binary,
+ * `build-windows/apps/Release/ninfer-serve.exe`. The directory and the .exe
+ * name both come from the Windows profile, so the build tree and the spelling
+ * have one home. `join` keeps the result cross-platform: the host's path module
+ * normalizes the separators, so the spawn resolves it on Windows, Linux, and
+ * macOS alike.
+ */
+export function ninferWindowsBinary() {
+    const binary = NINFER_WINDOWS.binary ?? 'ninfer-serve.exe';
+    const buildDir = NINFER_WINDOWS.buildDir;
+    return buildDir !== undefined ? join(buildDir, binary) : binary;
+}
+//# sourceMappingURL=ninferWindows.js.map

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

@@ -0,0 +1 @@
+