dsh-plugin-local-infer 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },
@@ -22,6 +22,7 @@
   ],
   "license": "MIT",
   "type": "module",
+  "packageManager": "pnpm@12.11.2",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
   },
@@ -85,6 +86,14 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.5-alpha.2"
   },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "clean": "tsc -b --clean"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.10.0",
@@ -94,13 +103,5 @@
     "typescript-eslint": "^8.71.2",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^5.0.4"
-  },
-  "scripts": {
-    "build": "tsc -b",
-    "typecheck": "tsc -b",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint .",
-    "clean": "tsc -b --clean"
   }
-}
+}

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

@@ -21,6 +21,7 @@ export interface LaunchPlan {
     env?: Record<string, string>;
     composeFile?: string;
     profile?: string;
+    composeArgs?: string;
     containerName?: string;
     modelId?: string;
     modelDirectory?: string;
@@ -32,12 +33,31 @@ export interface LaunchPlan {
  * specific engine: where the engine platform lives locally (the checkout and
  * build location) and the git repo that overrides the engine's default
  * upstream for this config. The deploy step consumes both: it clones the fork
- * (or the default upstream) into the engine directory.
+ * (or the default upstream) into the engine directory. `buildCommands`
+ * overrides the engine's local build command (the local build mode) and
+ * `dockerTag` overrides the docker image tag the docker deploy pulls (the
+ * docker build mode); each rides the platform map, so an engine switch keeps
+ * them.
  */
 export interface EnginePlatformConfig {
     engineId: string;
     engineDirectory?: string;
     engineFork?: string;
+    buildCommands?: string;
+    dockerTag?: string;
+}
+/**
+ * ProcessExitInfo is the one-shot answer to a spawned process's lifetime end:
+ * the exit code (null when a signal or a spawn failure ended it), the signal
+ * name (null when the process exited on its own), and the spawn error message
+ * when the child never ran (a missing binary). The host emits it exactly once
+ * per child, from the close event or the error event, so a crash or a pkill
+ * reaches the plugin's state through one seam instead of an uncaughtException.
+ */
+export interface ProcessExitInfo {
+    code: number | null;
+    signal: string | null;
+    error?: string;
 }
 /**
  * ProcessHandle is the handle to a spawned engine process: its pid and a kill
@@ -46,12 +66,17 @@ export interface EnginePlatformConfig {
  * the host captures the child's stdout and stderr, is the accumulated output
  * the launch step surfaces in the card's Logs section and writes to the log
  * file. A host that does not capture streams (a container it cannot read)
- * omits it.
+ * omits it. `onExit`, when the host watches the child, registers a listener
+ * fired once with the ProcessExitInfo when the child ends (a crash, a signal
+ * like a pkill, or a clean stop); a listener registered after the child has
+ * already ended fires immediately. A host that cannot watch (a stub, or a
+ * container it cannot read) omits it.
  */
 export interface ProcessHandle {
     pid: number;
     kill(): void;
     logs?: string;
+    onExit?(listener: (exit: ProcessExitInfo) => void): void;
 }
 /**
  * FetchResult is the answer to a health poll: the HTTP status and whether it
@@ -71,6 +96,15 @@ export interface FetchResult {
  */
 export interface LifecycleHost {
     run(command: string): Promise<CommandOutcome>;
+    /**
+     * Optional: run a command line and stream each stdout/stderr chunk to
+     * onOutput while it runs, so the Get step can append build output to the
+     * card's Logs section as it lands. A host that cannot stream omits it,
+     * and the caller falls back to run. No overall timeout: a full CUDA
+     * build legitimately runs past any fixed cap, and the card prices a
+     * stalled step with its own output-idle watchdog.
+     */
+    runStream?(command: string, onOutput: (chunk: string) => void): Promise<CommandOutcome>;
     spawn(argv: readonly string[], env: Record<string, string>, cwd?: string): ProcessHandle;
     fetch(url: string): Promise<FetchResult>;
     debug?: DebugLogger;
@@ -84,6 +118,23 @@ export interface HealthCheckOptions {
     pollMs?: number;
     maxAttempts?: number;
 }
+/**
+ * LaunchStep is the phase of a launch the card's Launch control prices: the
+ * system-dependency install (prereqs), the model and git checkout download
+ * (download), the source build or image pull (build), and the health poll that
+ * waits for the engine to come ready (launch). The service and the adapters
+ * report the step as each phase begins, so the card's button reads the phase
+ * that is actually running instead of a single "Launching..." for the whole
+ * rebuild. The card times out only the launch step; the rebuild steps (prereqs,
+ * download, build) run as long as they need to.
+ */
+export type LaunchStep = 'prereqs' | 'download' | 'build' | 'launch';
+/**
+ * LaunchProgress is the callback the launch flow calls as each phase begins.
+ * The route threads it from the streamed launch response through the service
+ * and the adapter's deploy step; a launch with no progress sink omits it.
+ */
+export type LaunchProgress = (step: LaunchStep) => void;
 /**
  * HealthResult is the answer to a /health poll: whether the engine is up, the
  * HTTP status, and a detail string for the UI.
@@ -93,17 +144,37 @@ export interface HealthResult {
     status?: number;
     detail?: string;
 }
+/**
+ * DeployOptions tunes a deploy run: `allowRunDeps` is the Play/Run trust gate
+ * (the card's "Allow one-click install (sudo)" checkbox). A local deploy that
+ * rebuilds the engine and leaves its binary out of the path links it into
+ * /usr/local/bin; the gate decides whether that sudo link runs (on) or is
+ * written to the card's Logs section for the user to run (off). `autoRebuild`
+ * is the card's "Auto Rebuild" checkbox: when false, the git sync (fetch,
+ * rebase, and the conditional rebuild) is skipped and the checkout launches
+ * as-is. Absent reads as true (the rebuild runs).
+ */
+export interface DeployOptions {
+    allowRunDeps?: boolean;
+    autoRebuild?: boolean;
+}
 /**
  * DeployResult reports whether a build-or-pull succeeded, with a detail for the
  * UI. `handle` is the spawned engine process when the deploy step started one
  * locally: the service reads its accumulated `logs` after the health poll, so
  * the launch result carries the engine's output for the card's Logs section and
- * the log file. A deploy that only pulls an image omits it.
+ * the log file, and attaches the handle's `onExit` listener to learn of a crash
+ * or a pkill. A deploy that starts no process (a compose up) omits it. `logs`
+ * is the deploy step's own captured output (the rebuild decision, the build
+ * command, and its output) the service prepends to the engine's output, so the
+ * card's Logs section shows the build a launch ran. A deploy that runs no
+ * rebuild (a docker pull, a compose up) omits it.
  */
 export interface DeployResult {
     ok: boolean;
     detail?: string;
     handle?: ProcessHandle;
+    logs?: string;
 }
 /**
  * EngineAdapter is the abstract base one subclass implements per engine. It
@@ -123,7 +194,7 @@ export declare abstract class EngineAdapter {
     abstract parameters(): readonly ParameterSpec[];
     abstract renderLaunch(config: Config, hw: HardwareProfile): LaunchPlan;
     abstract healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    abstract deploy(plan: LaunchPlan, platform?: EnginePlatformConfig): Promise<DeployResult>;
+    abstract deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
     abstract stop(plan: LaunchPlan): Promise<void>;
     /**
      * Optional: the host deps this engine's deploy step needs for a build mode,

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

@@ -13,13 +13,14 @@ export { DEFAULT_OS_RESERVE_MIB, estimateVram, KV_PAGE_TOKENS, pageRoundUp, TIGH
 export type { EstimateContext, EstimateOptions, SpeculationTerms, VramBreakdown, VramContribution, VramEstimate, VramModel, VramVerdict, } from './estimator.ts';
 export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage, resolveOsReserve, } from './reserve.ts';
 export { commandMatchesArgv, launchRecordFromPlan, reLinkRecord, } from './launch-record.ts';
+export { formatLaunchCommand } from './launch-command.ts';
 export type { ProviderLaunchRecord, ReLinkInput, ReLinkOutcome, } from './launch-record.ts';
 export type { EngineLaunchSignature, GpuUsageProbe, ProcessLine, ReserveResolution, ReserveSource, } from './reserve.ts';
 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 { DeployResult, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LifecycleHost, ProcessHandle, } from './adapter.ts';
+export type { DeployOptions, DeployResult, 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/index.js

@@ -9,6 +9,7 @@ export { detectHardware, parseNvidiaSmiGpu, } from "./hardware.js";
 export { DEFAULT_OS_RESERVE_MIB, estimateVram, KV_PAGE_TOKENS, pageRoundUp, TIGHT_HEADROOM_BYTES, } from "./estimator.js";
 export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage, resolveOsReserve, } from "./reserve.js";
 export { commandMatchesArgv, launchRecordFromPlan, reLinkRecord, } from "./launch-record.js";
+export { formatLaunchCommand } from "./launch-command.js";
 export { computeProviderStatuses, isGpuBusy, } from "./status.js";
 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.js";
 export { EngineAdapter } from "./adapter.js";

package/packages/core/lib/launch-command.d.ts

@@ -0,0 +1,13 @@
+import type { LaunchPlan } from './adapter.ts';
+/**
+ * formatLaunchCommand renders a launch plan as the shell command string the
+ * deploy step runs to start the engine: the quoted argv joined for a process
+ * or docker plan, or the `docker compose up` line for a compose plan. The
+ * card's Logs section shows the line above the engine's own output, so a
+ * user can read and copy the exact binary and arguments a launch started
+ * with. The Hyper-Qwen deploy runs this same string, so the printed line and
+ * the host command cannot drift. Returns undefined when the plan names no
+ * command (a non-compose plan with no argv).
+ */
+export declare function formatLaunchCommand(plan: LaunchPlan): string | undefined;
+//# sourceMappingURL=launch-command.d.ts.map

package/packages/core/lib/launch-command.js

@@ -0,0 +1,64 @@
+/**
+ * formatLaunchCommand renders a launch plan as the shell command string the
+ * deploy step runs to start the engine: the quoted argv joined for a process
+ * or docker plan, or the `docker compose up` line for a compose plan. The
+ * card's Logs section shows the line above the engine's own output, so a
+ * user can read and copy the exact binary and arguments a launch started
+ * with. The Hyper-Qwen deploy runs this same string, so the printed line and
+ * the host command cannot drift. Returns undefined when the plan names no
+ * command (a non-compose plan with no argv).
+ */
+export function formatLaunchCommand(plan) {
+    if (plan.kind === 'compose') {
+        // The user's compose arguments (the card's docker-tag field) override the
+        // default profile: the flags the up step runs before the required `up -d`.
+        // An empty field reads as "use the default profile", so the up step falls
+        // back to the engine's own default.
+        const composeArgs = plan.composeArgs?.split(/\s+/).filter((token) => token !== '');
+        if (composeArgs !== undefined && composeArgs.length > 0) {
+            return [
+                'docker',
+                'compose',
+                '-f',
+                plan.composeFile ?? 'docker-compose.yml',
+                ...composeArgs,
+                'up',
+                '-d',
+            ]
+                .map(quoteArg)
+                .join(' ');
+        }
+        // The compose defaults match the adapter's renderLaunch fallbacks, so a
+        // plan built from a bare config still spells a runnable command.
+        return [
+            'docker',
+            'compose',
+            '-f',
+            plan.composeFile ?? 'docker-compose.yml',
+            '--profile',
+            plan.profile ?? 'single',
+            'up',
+            '--pull',
+            'always',
+            '-d',
+        ]
+            .map(quoteArg)
+            .join(' ');
+    }
+    const argv = plan.argv;
+    if (argv === undefined || argv.length === 0)
+        return undefined;
+    return argv.map(quoteArg).join(' ');
+}
+/**
+ * quoteArg renders one argv token for display: a token made only of shell-
+ * safe characters rides bare, anything else lands in single quotes with
+ * embedded quotes escaped, so the printed line pastes back into a shell
+ * unchanged.
+ */
+function quoteArg(token) {
+    if (token !== '' && /^[A-Za-z0-9@%+=:,./_-]+$/.test(token))
+        return token;
+    return `'${token.replaceAll("'", "'\\''")}'`;
+}
+//# sourceMappingURL=launch-command.js.map

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

@@ -67,7 +67,8 @@ export interface ModelDirectoryEntry {
 /**
  * modelEntriesForEngine filters a model directory listing down to the model
  * entries the engine's Model dropdown offers: NInfer takes `.ninfer`
- * artifacts, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
+ * artifacts, Infernix takes `.ninfer` artifacts and its own `.infernix`
+ * files, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
  * directories that hold a `.safetensors` weight file. Every other engine
  * (Strata) offers nothing, matching its empty default list. The result is
  * sorted, so the dropdown order is stable across summary fetches.

package/packages/core/lib/models.js

@@ -61,7 +61,8 @@ export function hfChatTemplateCommand(repo, directory) {
 /**
  * modelEntriesForEngine filters a model directory listing down to the model
  * entries the engine's Model dropdown offers: NInfer takes `.ninfer`
- * artifacts, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
+ * artifacts, Infernix takes `.ninfer` artifacts and its own `.infernix`
+ * files, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
  * directories that hold a `.safetensors` weight file. Every other engine
  * (Strata) offers nothing, matching its empty default list. The result is
  * sorted, so the dropdown order is stable across summary fetches.
@@ -74,6 +75,14 @@ export function modelEntriesForEngine(entries, engineId) {
                 .filter((entry) => !entry.isDirectory && entry.name.endsWith('.ninfer'))
                 .map((entry) => entry.name);
             break;
+        case 'infernix':
+            // Infernix loads NInfer artifacts unchanged plus its own `.infernix`
+            // files, so the dropdown offers both extensions.
+            names = entries
+                .filter((entry) => !entry.isDirectory &&
+                (entry.name.endsWith('.ninfer') || entry.name.endsWith('.infernix')))
+                .map((entry) => entry.name);
+            break;
         case 'llamacpp':
             names = entries
                 .filter((entry) => !entry.isDirectory && entry.name.endsWith('.gguf'))

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

@@ -1,4 +1,5 @@
 import type { GpuUsageProbe } from './reserve.ts';
+import type { Config } from './config.ts';
 /**
  * ProviderStatus is the running-state the plugin card paints each saved
  * provider's status dot: green while the engine is confirmed serving the
@@ -10,12 +11,19 @@ export type ProviderStatus = 'running' | 'stopped' | 'unsure';
  * ProviderRef is the identity side of one saved provider config: the stable
  * id the card renders and the engine and model it serves. The model is
  * optional because a config that names no model cannot be confirmed against
- * a running engine, and reads as unsure rather than a guess.
+ * a running engine, and reads as unsure rather than a guess. The config is
+ * optional and lets the detector price the provider's own launch signature
+ * (the engine binary the build mode runs, the port it binds) rather than the
+ * adapter's default-port signature; the port is the resolved bind port the
+ * detector read from that signature, and the resolver ties a running engine
+ * to the provider only when the ports agree.
  */
 export interface ProviderRef {
     id: string;
     engine: string;
     model?: string;
+    config?: Config;
+    port?: number;
 }
 /**
  * RunningEngineRef is one engine the detector confirmed live: the engine id,

package/packages/core/lib/status.js

@@ -28,7 +28,12 @@ export function isGpuBusy(usage) {
 export function computeProviderStatuses(input) {
     const statuses = {};
     for (const provider of input.providers) {
-        const matches = input.running.filter((ref) => ref.engineId === provider.engine);
+        // A provider that names a port only counts an engine running on that
+        // port: two configs of one engine on different ports are distinct
+        // engines, and a match on the other port must not confirm (or deny) this
+        // config's model. An unnamed port keeps the engine-wide match.
+        const matches = input.running.filter((ref) => ref.engineId === provider.engine &&
+            (provider.port === undefined || ref.port === undefined || ref.port === provider.port));
         if (matches.length > 0) {
             // The engine is running. The question is which model it serves: the
             // detector's identified model, if it tied one, else unknown.

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

@@ -0,0 +1,125 @@
+/**
+ * The per-engine acquisition data and the Get step. Each engine declares its
+ * git source (the upstream repo, the branch the rebase targets, and the build
+ * steps the checkout runs) as data here; the adapters' deploy steps and the
+ * /local-infer/get route both consume the same constants, so a build command
+ * has one home. The sync step clones a missing checkout, and a clean existing
+ * checkout is fetched and rebased onto the upstream branch; a checkout with
+ * local changes aborts, because a rebase would eat the user's work.
+ * @module dsh-plugin-local-infer/providers/acquire
+ */
+import type { LifecycleHost } from '../../core/lib/index.js';
+/**
+ * EngineSource is the per-engine acquisition data: the upstream git repo the
+ * clone step uses when no fork is provided, the branch the fetch/rebase step
+ * rebases onto, and the build steps run in the checkout after a clone or a
+ * rebase. A build step is a shell command line; the `{dir}` placeholder is
+ * replaced with the checkout directory before the step runs.
+ */
+export interface EngineSource {
+    repo: string;
+    branch: string;
+    buildSteps: readonly string[];
+}
+/**
+ * The remote name a user-provided fork is added under, so the checkout's own
+ * origin (the upstream it was cloned from) survives the fork override.
+ */
+export declare const FORK_REMOTE = "dsh-fork";
+/**
+ * The per-engine git sources, keyed by engine id. NInfer and Infernix build
+ * 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.
+ */
+export declare const ENGINE_SOURCES: Record<string, EngineSource>;
+/**
+ * AcquireLog receives one line (or chunk) of Get output as it lands, so the
+ * route can stream it to the card's Logs section.
+ */
+export type AcquireLog = (chunk: string) => void;
+/**
+ * EngineStepResult reports one Get step (sync or build): whether it passed,
+ * whether it aborted on a rule (a dirty checkout), and a detail the Logs
+ * section shows when it did not pass.
+ */
+export interface EngineStepResult {
+    ok: boolean;
+    aborted?: boolean;
+    detail?: string;
+}
+/**
+ * engineSource reads the registered acquisition data for an engine id, or
+ * undefined when none is registered.
+ */
+export declare function engineSource(engineId: string): EngineSource | undefined;
+/**
+ * engineBuildSteps reads the build steps an engine runs in its checkout, so
+ * the adapter's deploy step and the Get build step share one list.
+ */
+export declare function engineBuildSteps(engineId: string): readonly string[];
+/**
+ * syncEngineRepo brings the engine checkout to the listed source. A missing
+ * checkout is a fresh clone of the fork (or the engine's upstream repo when
+ * no fork is provided). An existing checkout with local changes aborts, so
+ * the user's work is never rebased away; a clean checkout fetches the listed
+ * fork (added as the named fork remote when provided, origin when not) and
+ * rebases onto its branch. Every command echoes into log as it runs.
+ */
+export declare function syncEngineRepo(host: LifecycleHost, request: {
+    engineId: string;
+    directory: string;
+    fork?: string;
+}, log: AcquireLog): Promise<EngineStepResult>;
+/**
+ * SyncRebuildRequest names the checkout the conditional rebuild prices: the
+ * engine, its directory, the optional fork remote, the engine binary the
+ * symlink step links when a rebuild leaves it out of the path, and the
+ * Play/Run trust gate that decides whether that symlink runs (on) or is
+ * written to the logs (off).
+ */
+export interface SyncRebuildRequest {
+    engineId: string;
+    directory: string;
+    fork?: string;
+    binary?: string;
+    allowRunDeps?: boolean;
+}
+/**
+ * SyncRebuildResult reports the conditional rebuild: whether it passed,
+ * whether a build actually ran (a fresh clone, or a rebase of a checkout that
+ * was behind), a detail for a failure, and the captured log text (the decision,
+ * the build command, and its output) the deploy step threads to the card's
+ * Logs section.
+ */
+export interface SyncRebuildResult {
+    ok: boolean;
+    rebuilt: boolean;
+    detail?: string;
+    logs: string;
+}
+/**
+ * syncAndRebuildEngine brings the engine checkout to the listed source and
+ * rebuilds it only when it needs to. A missing checkout is a fresh clone of
+ * the fork (or the upstream repo) and always builds. An existing checkout is
+ * fetched and priced against the remote branch: when it is behind and clean,
+ * the primary branch is checked out, rebased onto the remote branch, and the
+ * working tree is cleaned (git clean -fxd) before the build; when it is not
+ * behind, or it carries local changes, the build is skipped so a launch does
+ * not rebuild a checkout that is current. The decision, the build command,
+ * and its output stream through log and are returned as the result's logs.
+ * After a rebuild, the engine binary is checked against the path; when a build
+ * that did not install it leaves it out, a symlink into /usr/local/bin is
+ * added (run when the trust gate is on, written to the logs when it is off).
+ */
+export declare function syncAndRebuildEngine(host: LifecycleHost, request: SyncRebuildRequest, log: AcquireLog): Promise<SyncRebuildResult>;
+/**
+ * buildEngineRepo runs the engine's build steps in the checkout, streaming
+ * each step's output through log. An engine with no build steps (the compose
+ * 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>;
+//# sourceMappingURL=acquire.d.ts.map