@vtxmacro/cli 2026.9.51 → 2026.9.52

package/bin/vtx-service-launcher.js

@@ -0,0 +1,1389 @@
+// lib/runtime-policy.generated.json
+var runtime_policy_generated_default = {
+  ui: {
+    performance_defaults: {
+      default_timeframe: "30d"
+    },
+    execution_metadata_retry: {
+      max_attempts: 3,
+      base_delay_milliseconds: 2e3,
+      max_delay_milliseconds: 3e4
+    },
+    auth_bootstrap_retry: {
+      max_attempts: 3,
+      jitter_milliseconds: 750,
+      base_delay_milliseconds: 500,
+      min_delay_milliseconds: 250,
+      max_delay_milliseconds: 1e4
+    }
+  },
+  ai_dashboard: {
+    market_news_bounds: {
+      max_items_min: 1,
+      max_items_max: 100,
+      lookback_hours_min: 1,
+      lookback_hours_max: 168,
+      max_items_steps: [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        15,
+        20,
+        25,
+        30,
+        40,
+        50,
+        60,
+        75,
+        90,
+        100
+      ],
+      lookback_hours_steps: [
+        1,
+        2,
+        4,
+        8,
+        12,
+        24,
+        48,
+        72,
+        168
+      ]
+    }
+  },
+  trading: {
+    engine: {
+      client_runtime: {
+        recovery: {
+          resume_retry_base_delay_ms: 1e3,
+          resume_retry_max_delay_ms: 3e4,
+          transient_load_min_delay_ms: 3e4,
+          transient_load_max_delay_ms: 12e4,
+          rate_limit_buffer_ms: 1e3,
+          rate_limit_max_delay_ms: 3e5,
+          engine_stop_settle_retry_delay_ms: 250,
+          recoverable_reset_settle_retry_delay_ms: 1500,
+          local_ai_preflight_timeout_ms: 3e3,
+          surge_stagger_max_ms: 6e4,
+          surge_stagger_min_ms: 2e3,
+          surge_stagger_min_candidates: 4,
+          stagger_deadline_ttl_ms: 3e5,
+          server_active_reprobe_delay_ms: 6e4,
+          transient_load_jitter_ms: 1e4,
+          cross_host_completed_ttl_ms: 15e3,
+          telemetry_dedupe_ttl_ms: 5e3,
+          browser_presence_heartbeat_interval_ms: 3e4,
+          host_liveness_heartbeat_interval_ms: 3e4,
+          host_liveness_recovery_nudge_ttl_ms: 1e4
+        }
+      }
+    }
+  },
+  external_inference: {
+    service: {
+      update_check_interval_ms: 3e5,
+      update_registry_timeout_ms: 15e3,
+      bootstrap_readiness_timeout_ms: 6e5,
+      bootstrap_stop_timeout_ms: 1e4,
+      startup_max_attempts: 40,
+      startup_poll_interval_ms: 250,
+      restart_stable_uptime_ms: 6e4,
+      restart_backoff_base_ms: 1e3,
+      restart_backoff_max_ms: 3e4,
+      restart_exponent_max: 5
+    },
+    claim_diagnostics: {
+      event_loop_sample_interval_ms: 100
+    }
+  },
+  desktop: {
+    runtime_watchdog: {
+      ping_interval_milliseconds: 15e3,
+      telemetry_interval_milliseconds: 3e5
+    }
+  },
+  screener: {
+    resource_scheduler: {
+      client_lock_ttl_milliseconds: 12e4,
+      client_poll_interval_milliseconds: 250
+    }
+  },
+  deployment: {
+    cutover_buffer: {
+      target_timeout_ms: 3e3,
+      retired_timeout_ms: 45e3,
+      max_body_bytes: 33554432,
+      max_inflight: 16,
+      max_queue: 64
+    }
+  },
+  exchange: {
+    hyperliquid: {
+      client_public_read_budget: {
+        max_weight: 900,
+        window_seconds: 60,
+        cooldown_seconds: 60,
+        metadata_ttl_seconds: 300,
+        user_fees_ttl_seconds: 300,
+        account_mode_ttl_seconds: 30,
+        default_request_weight: 20,
+        cache_max_entries: 512
+      },
+      read_budget: {
+        weights: {
+          exchangeStatus: 2,
+          clearinghouseState: 2,
+          spotClearinghouseState: 2,
+          l2Book: 2,
+          allMids: 2,
+          userFills: 120,
+          userFillsByTime: 120,
+          historicalOrders: 120,
+          twapHistory: 120,
+          userTwapSliceFills: 120,
+          userFunding: 45,
+          userNonFundingLedgerUpdates: 45,
+          candleSnapshot: 104,
+          userRole: 60,
+          userAbstraction: 20,
+          userDexAbstraction: 20,
+          userActiveAssetData: 20,
+          activeAssetData: 20,
+          openOrders: 20,
+          orderStatus: 2,
+          portfolio: 20,
+          userFees: 20,
+          metaAndAssetCtxs: 20,
+          meta: 20,
+          perpDexs: 20,
+          spotMeta: 20,
+          approvedAgents: 20,
+          authorizedAgents: 20,
+          agents: 20,
+          apiWallets: 20
+        }
+      }
+    }
+  }
+};
+
+// lib/inference-host/service-launcher.ts
+import { spawn as spawn2 } from "node:child_process";
+import { appendFile, readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// lib/inference-host/config.ts
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, realpath, rename, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, win32 as windowsPath } from "node:path";
+var MAX_INFERENCE_PRIVATE_FILE_BYTES = 16 * 1024 * 1024;
+var WINDOWS_PRIVATE_ACL_BROKER_SCRIPT = `$ErrorActionPreference='Stop'
+$ProgressPreference='SilentlyContinue'
+while(($line=[Console]::In.ReadLine()) -ne $null) {
+  $requestId=$null
+  $failureStage='request_validation'
+  try {
+    if($line.Length -lt 2 -or $line.Length -gt 65536) { throw 'invalid request size' }
+    $request=$line | ConvertFrom-Json
+    $names=@($request.PSObject.Properties.Name | Sort-Object)
+    if(($names -join ',') -ne 'id,kind,mode,path_b64') { throw 'invalid request shape' }
+    if($request.id -isnot [long] -and $request.id -isnot [int]) { throw 'invalid request id' }
+    $requestId=[long]$request.id
+    if($requestId -lt 1) { throw 'invalid request id' }
+    $kind=[string]$request.kind
+    $mode=[string]$request.mode
+    if($kind -ne 'directory' -and $kind -ne 'file') { throw 'invalid path kind' }
+    if($mode -ne 'harden' -and $mode -ne 'verify' -and $mode -ne 'verify-owner') { throw 'invalid ACL mode' }
+    $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String([string]$request.path_b64))
+    if([string]::IsNullOrWhiteSpace($path) -or $path.Length -gt 32767 -or $path.Contains([char]0)) { throw 'invalid path' }
+    $failureStage='path_lookup'
+    if(-not (Test-Path -LiteralPath $path)) {
+      [Console]::Out.WriteLine((@{id=$requestId;status='missing'} | ConvertTo-Json -Compress))
+      continue
+    }
+    $failureStage='principal_resolution'
+    $currentIdentity=[Security.Principal.WindowsIdentity]::GetCurrent()
+    $current=$currentIdentity.User
+    $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+    $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+    $currentIsAdmin=(New-Object Security.Principal.WindowsPrincipal($currentIdentity)).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+    $allowed=@($current.Value,$system.Value,$admins.Value)
+    if($mode -eq 'harden') {
+      $failureStage='acl_read'
+      $acl=Get-Acl -LiteralPath $path
+      $originalAccess=$acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)
+      $failureStage='owner_validation'
+      $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+      if($existingOwner -ne $current.Value -and ($existingOwner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+      $failureStage='acl_mutation'
+      $acl.SetAccessRuleProtection($true,$false)
+      foreach($existingRule in @($acl.Access)) { [void]$acl.RemoveAccessRuleSpecific($existingRule) }
+      $inherit=if($kind -eq 'directory') {
+        [Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
+      } else { [Security.AccessControl.InheritanceFlags]::None }
+      foreach($sid in @($current,$system,$admins)) {
+        $rule=New-Object Security.AccessControl.FileSystemAccessRule(
+          $sid,
+          [Security.AccessControl.FileSystemRights]::FullControl,
+          $inherit,
+          [Security.AccessControl.PropagationFlags]::None,
+          [Security.AccessControl.AccessControlType]::Allow
+        )
+        [void]$acl.AddAccessRule($rule)
+      }
+      $failureStage='acl_write'
+      if($originalAccess -ne $acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)) {
+        (Get-Item -LiteralPath $path).SetAccessControl($acl)
+      }
+    }
+    $failureStage='acl_readback'
+    $actual=Get-Acl -LiteralPath $path
+    $failureStage='acl_verification'
+    $owner=(New-Object Security.Principal.NTAccount($actual.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+    if($owner -ne $current.Value -and ($owner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+    if($mode -ne 'verify-owner') {
+      if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
+      $userFull=$false
+      foreach($rule in $actual.Access) {
+        $sid=$rule.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value
+        if($rule.IsInherited -or $allowed -notcontains $sid -or $rule.AccessControlType -ne [Security.AccessControl.AccessControlType]::Allow) {
+          throw 'private ACL contains an unauthorized access rule'
+        }
+        if($sid -eq $current.Value -and (($rule.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl)) { $userFull=$true }
+      }
+      if(-not $userFull) { throw 'private ACL does not grant the current user full control' }
+    }
+    [Console]::Out.WriteLine((@{id=$requestId;status='ok'} | ConvertTo-Json -Compress))
+  } catch {
+    [Console]::Out.WriteLine((@{id=$requestId;status='error';error_code=$failureStage} | ConvertTo-Json -Compress))
+  }
+}`;
+var WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS = 15e3;
+var WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS = 9e4;
+var SMALL_IDENTITY_COMMAND_TIMEOUT_MS = 5e3;
+var windowsPowerShellEnvironment = (extra = {}) => {
+  const sanitizedExtra = { ...extra };
+  delete sanitizedExtra.PSModulePath;
+  const windowsRoot = process.env.SystemRoot ?? process.env.WINDIR;
+  return {
+    ...sanitizedExtra,
+    NODE_ENV: process.env.NODE_ENV,
+    SystemRoot: process.env.SystemRoot,
+    WINDIR: process.env.WINDIR,
+    ComSpec: process.env.ComSpec,
+    PATHEXT: process.env.PATHEXT,
+    PSModulePath: windowsRoot ? windowsPath.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "Modules") : void 0,
+    TEMP: process.env.TEMP,
+    TMP: process.env.TMP
+  };
+};
+var windowsPrivateAclBrokerInvocation = () => ({
+  args: [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-EncodedCommand",
+    Buffer.from(WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, "utf16le").toString("base64")
+  ],
+  env: windowsPowerShellEnvironment()
+});
+var WindowsPrivateAclBroker = class {
+  constructor(dependencies = {}) {
+    this.child = null;
+    this.requestSequence = 0;
+    this.queue = Promise.resolve();
+    this.pending = null;
+    this.outputBuffer = "";
+    this.idleTimer = null;
+    this.run = async (path, kind, mode) => {
+      const operation = this.queue.then(
+        () => this.dispatch(path, kind, mode),
+        () => this.dispatch(path, kind, mode)
+      );
+      this.queue = operation.then(() => void 0, () => void 0);
+      await operation;
+    };
+    this.requestTimeoutMs = dependencies.requestTimeoutMs ?? 15e3;
+    this.startupRequestTimeoutMs = dependencies.startupRequestTimeoutMs ?? WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS;
+    this.idleShutdownMs = dependencies.idleShutdownMs ?? 3e4;
+    this.spawnProcess = dependencies.spawnProcess ?? (() => {
+      const invocation = windowsPrivateAclBrokerInvocation();
+      return spawn("powershell.exe", [...invocation.args], {
+        env: invocation.env,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    });
+  }
+  scheduleIdleShutdown() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      const child = this.child;
+      if (!child || this.pending) return;
+      this.child = null;
+      this.outputBuffer = "";
+      child.stdin.end();
+      const force = setTimeout(() => child.kill("SIGKILL"), 1e3);
+      force.unref();
+      child.once("exit", () => clearTimeout(force));
+    }, this.idleShutdownMs);
+    this.idleTimer.unref();
+  }
+  failChild(child, error) {
+    if (this.child !== child) return;
+    this.child = null;
+    this.outputBuffer = "";
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    child.kill("SIGKILL");
+  }
+  acceptLine(child, line) {
+    const pending = this.pending;
+    if (!pending || !line || line.length > 4096) {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    let response;
+    try {
+      const parsed = JSON.parse(line);
+      const status = String(parsed.status);
+      const expectedKeys = status === "error" ? "error_code\0id\0status" : "id\0status";
+      if (Object.keys(parsed).sort().join("\0") !== expectedKeys || parsed.id !== pending.id || !["ok", "missing", "error"].includes(status) || status === "error" && ![
+        "request_validation",
+        "path_lookup",
+        "principal_resolution",
+        "acl_read",
+        "owner_validation",
+        "acl_mutation",
+        "acl_write",
+        "acl_readback",
+        "acl_verification"
+      ].includes(String(parsed.error_code))) throw new Error("invalid response");
+      response = parsed;
+    } catch {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    this.pending = null;
+    clearTimeout(pending.timer);
+    if (response.status === "ok") {
+      pending.resolve();
+    } else if (response.status === "missing") {
+      const error = new Error("Windows private path no longer exists.");
+      error.code = "ENOENT";
+      pending.reject(error);
+    } else {
+      pending.reject(new Error(
+        `Windows private ACL ${pending.mode} failed (${response.error_code}).`
+      ));
+    }
+    this.scheduleIdleShutdown();
+  }
+  ensureChild() {
+    if (this.child && this.child.exitCode === null && !this.child.killed) {
+      return { child: this.child, startedNow: false };
+    }
+    const child = this.spawnProcess();
+    this.child = child;
+    this.outputBuffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (this.child !== child) return;
+      this.outputBuffer += chunk;
+      if (this.outputBuffer.length > 65536) {
+        this.failChild(child, new Error("Windows private ACL broker exceeded its output limit."));
+        return;
+      }
+      while (this.child === child) {
+        const newline = this.outputBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = this.outputBuffer.slice(0, newline).trim();
+        this.outputBuffer = this.outputBuffer.slice(newline + 1);
+        this.acceptLine(child, line);
+      }
+    });
+    child.stderr.on("data", () => void 0);
+    child.once("error", () => {
+      this.failChild(child, new Error("Windows private ACL broker failed to start."));
+    });
+    child.once("exit", () => {
+      this.failChild(child, new Error("Windows private ACL broker exited before confirmation."));
+    });
+    child.unref();
+    for (const stream of [child.stdin, child.stdout, child.stderr]) {
+      stream.unref?.();
+    }
+    return { child, startedNow: true };
+  }
+  async dispatch(path, kind, mode) {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const id = ++this.requestSequence;
+    const request = `${JSON.stringify({
+      id,
+      kind,
+      mode,
+      path_b64: Buffer.from(path, "utf8").toString("base64")
+    })}
+`;
+    if (Buffer.byteLength(request, "utf8") > 65536) {
+      throw new Error("Windows private ACL broker request exceeds its input limit.");
+    }
+    const { child, startedNow } = this.ensureChild();
+    const timeoutMs = startedNow ? this.startupRequestTimeoutMs : this.requestTimeoutMs;
+    await new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.failChild(child, new Error("Windows private ACL broker request timed out."));
+      }, timeoutMs);
+      this.pending = { id, mode, resolve: resolvePromise, reject, timer };
+      child.stdin.write(request, "utf8", (error) => {
+        if (error) {
+          this.failChild(child, new Error("Windows private ACL broker request failed."));
+        }
+      });
+    });
+  }
+  close() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+    const child = this.child;
+    this.child = null;
+    this.outputBuffer = "";
+    if (child) child.stdin.end();
+  }
+};
+var defaultWindowsPrivateAclBroker = new WindowsPrivateAclBroker();
+var runWindowsPrivateAcl = async (path, kind, mode) => await defaultWindowsPrivateAclBroker.run(path, kind, mode);
+var windowsAclCache = /* @__PURE__ */ new Map();
+var windowsAclIdentity = async (path) => {
+  const metadata = await lstat(path, { bigint: true });
+  return {
+    dev: metadata.dev,
+    ino: metadata.ino,
+    ctimeNs: metadata.ctimeNs,
+    mtimeNs: metadata.mtimeNs,
+    mode: metadata.mode,
+    size: metadata.size
+  };
+};
+var aclCacheKey = (path, kind, mode) => `${kind}:${mode}:${resolve(path)}`;
+var secureWindowsPrivatePath = async (path, kind, mode, platform = process.platform, runner = runWindowsPrivateAcl) => {
+  if (platform !== "win32") return;
+  const key = aclCacheKey(path, kind, mode);
+  const before = await windowsAclIdentity(path);
+  const cached = windowsAclCache.get(key);
+  if (cached && cached.dev === before.dev && cached.ino === before.ino && cached.ctimeNs === before.ctimeNs && cached.mtimeNs === before.mtimeNs && cached.mode === before.mode && cached.size === before.size) return;
+  await runner(path, kind, mode);
+  windowsAclCache.set(key, await windowsAclIdentity(path));
+};
+var invalidateWindowsAclCache = (path) => {
+  for (const kind of ["file", "directory"]) {
+    for (const mode of ["harden", "verify", "verify-owner"]) {
+      windowsAclCache.delete(aclCacheKey(path, kind, mode));
+    }
+  }
+};
+var rebindHardenedWindowsAclAfterRename = async (source, destination, kind, expected) => {
+  const resolvedSource = resolve(source);
+  const resolvedDestination = resolve(destination);
+  if (resolvedSource === resolvedDestination || dirname(resolvedSource) !== dirname(resolvedDestination)) {
+    throw new Error("Windows private ACL cache rename boundary is invalid.");
+  }
+  const published = await windowsAclIdentity(destination);
+  if (published.dev !== expected.dev || published.ino !== expected.ino || published.mode !== expected.mode || published.mtimeNs !== expected.mtimeNs || published.size !== expected.size) {
+    invalidateWindowsAclCache(source);
+    invalidateWindowsAclCache(destination);
+    throw new Error("Windows private file identity changed during atomic publication.");
+  }
+  invalidateWindowsAclCache(source);
+  invalidateWindowsAclCache(destination);
+  for (const mode of ["harden", "verify", "verify-owner"]) {
+    windowsAclCache.set(aclCacheKey(destination, kind, mode), published);
+  }
+};
+var rebindHardenedWindowsDirectoryAfterOwnedMutation = async (path, expected) => {
+  const current = await windowsAclIdentity(path);
+  if (current.dev !== expected.dev || current.ino !== expected.ino || current.mode !== expected.mode) {
+    invalidateWindowsAclCache(path);
+    throw new Error("Windows private directory identity changed during atomic publication.");
+  }
+  invalidateWindowsAclCache(path);
+  for (const mode of ["harden", "verify", "verify-owner"]) {
+    windowsAclCache.set(aclCacheKey(path, "directory", mode), current);
+  }
+};
+var isDefaultWindowsPrivatePath = (path, root = resolve(homedir(), ".vtx", "inference-host")) => {
+  const child = relative(root, resolve(path));
+  return child === "" || !child.startsWith("..") && !child.includes(":");
+};
+var secureExistingWindowsPath = async (path, kind, platform = process.platform, runner = runWindowsPrivateAcl, defaultRoot = resolve(homedir(), ".vtx", "inference-host")) => {
+  if (platform !== "win32") return;
+  if (!isDefaultWindowsPrivatePath(path, defaultRoot)) {
+    await secureWindowsPrivatePath(path, kind, "verify", platform, runner);
+    return;
+  }
+  await secureWindowsPrivatePath(path, kind, "harden", platform, runner);
+};
+var linuxProcessIdentity = async (pid) => {
+  try {
+    const [bootId, statLine] = await Promise.all([
+      readFile("/proc/sys/kernel/random/boot_id", "utf8"),
+      readFile(`/proc/${pid}/stat`, "utf8")
+    ]);
+    const fields = statLine.slice(statLine.lastIndexOf(")") + 2).trim().split(/\s+/u);
+    const startTicks = fields[19];
+    return startTicks ? `linux:${bootId.trim()}:${startTicks}` : null;
+  } catch {
+    return null;
+  }
+};
+var windowsProcessIdentityInvocation = (pid) => {
+  const script = `$ErrorActionPreference='Stop';$p=[Diagnostics.Process]::GetProcessById([int]$env:VTX_PROCESS_PID);[Console]::Out.Write($p.StartTime.ToUniversalTime().ToFileTimeUtc())`;
+  return {
+    args: [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ],
+    env: windowsPowerShellEnvironment({ VTX_PROCESS_PID: String(pid) }),
+    timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+  };
+};
+var windowsBootIdentityInvocation = () => {
+  const script = `$ErrorActionPreference='Stop';$s=[System.Management.ManagementObjectSearcher]::new('SELECT LastBootUpTime FROM Win32_OperatingSystem');try{$c=$s.Get();$e=$c.GetEnumerator();if(-not $e.MoveNext()){throw 'boot identity unavailable'};$raw=[string]$e.Current['LastBootUpTime'];$v=[System.Management.ManagementDateTimeConverter]::ToDateTime($raw).ToUniversalTime().ToFileTimeUtc();[Console]::Out.Write($v)}finally{if($c){$c.Dispose()};$s.Dispose()}`;
+  return {
+    args: [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ],
+    env: windowsPowerShellEnvironment(),
+    timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+  };
+};
+var windowsProcessIdentity = async (pid) => await new Promise((resolvePromise) => {
+  const invocation = windowsProcessIdentityInvocation(pid);
+  const child = spawn("powershell.exe", [...invocation.args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env: invocation.env
+  });
+  const output = [];
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, invocation.timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    if (output.reduce((total, item) => total + item.byteLength, 0) + Buffer.byteLength(chunk) > 1024) {
+      child.kill("SIGKILL");
+      settle(null);
+      return;
+    }
+    output.push(Buffer.from(chunk));
+  });
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => {
+    const started = Buffer.concat(output).toString("utf8").trim();
+    settle(code === 0 && /^\d+$/u.test(started) ? `win32:${started}` : null);
+  });
+});
+var darwinProcessIdentity = async (pid) => await new Promise((resolvePromise) => {
+  const child = spawn("ps", ["-p", String(pid), "-o", "lstart="], {
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const output = [];
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, 5e3);
+  child.stdout.on("data", (chunk) => output.push(Buffer.from(chunk)));
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => {
+    const started = Date.parse(Buffer.concat(output).toString("utf8").trim());
+    settle(code === 0 && Number.isFinite(started) ? `darwin:${Math.floor(started / 1e3)}` : null);
+  });
+});
+var runSmallIdentityCommand = async (command, args, env, timeoutMs = SMALL_IDENTITY_COMMAND_TIMEOUT_MS) => await new Promise((resolvePromise) => {
+  const child = spawn(command, [...args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env
+  });
+  const output = [];
+  let bytes = 0;
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > 4096) {
+      child.kill("SIGKILL");
+      settle(null);
+      return;
+    }
+    output.push(Buffer.from(chunk));
+  });
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => settle(
+    code === 0 ? Buffer.concat(output).toString("utf8").trim() || null : null
+  ));
+});
+var cachedSystemBootIdentity = null;
+var readInferenceSystemBootIdentity = async (platform = process.platform) => {
+  if (platform === process.platform && cachedSystemBootIdentity) {
+    return await cachedSystemBootIdentity;
+  }
+  const read = async () => {
+    let identity = null;
+    if (platform === "linux") {
+      try {
+        identity = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+      } catch {
+        identity = null;
+      }
+    } else if (platform === "win32") {
+      const invocation = windowsBootIdentityInvocation();
+      identity = await runSmallIdentityCommand(
+        "powershell.exe",
+        invocation.args,
+        invocation.env,
+        invocation.timeoutMs
+      );
+    } else if (platform === "darwin") {
+      identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
+    }
+    if (!identity || /[\r\n\0]/u.test(identity)) {
+      throw new Error("Inference host could not establish the current system boot identity.");
+    }
+    return `${platform}:${identity}`;
+  };
+  const pending = read();
+  if (platform === process.platform) cachedSystemBootIdentity = pending;
+  try {
+    return await pending;
+  } catch (error) {
+    if (platform === process.platform) cachedSystemBootIdentity = null;
+    throw error;
+  }
+};
+var defaultProcessIdentity = async (pid) => {
+  if (process.platform === "linux") return await linuxProcessIdentity(pid);
+  if (process.platform === "win32") return await windowsProcessIdentity(pid);
+  if (process.platform === "darwin") return await darwinProcessIdentity(pid);
+  return null;
+};
+var defaultCurrentProcessIdentity = async () => {
+  const identity = await defaultProcessIdentity(process.pid);
+  if (!identity) throw new Error("Inference host could not establish its process-start identity.");
+  return identity;
+};
+var processLockObservationCache = /* @__PURE__ */ new Map();
+var inferenceProcessIdentitiesMatch = (stored, observed) => stored === observed;
+async function ensureInferencePrivateDirectory(path, dependencies = {}) {
+  const platform = dependencies.platform ?? process.platform;
+  const runner = dependencies.runner ?? runWindowsPrivateAcl;
+  const defaultRoot = dependencies.defaultRoot ?? resolve(homedir(), ".vtx", "inference-host");
+  let created = false;
+  try {
+    const before = await lstat(path);
+    if (before.isSymbolicLink() || !before.isDirectory()) {
+      throw new Error("Inference host state directory is unsafe.");
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    await mkdir(path, { recursive: true, mode: 448 });
+    created = true;
+  }
+  const after = await lstat(path);
+  if (after.isSymbolicLink() || !after.isDirectory()) {
+    throw new Error("Inference host state directory is unsafe.");
+  }
+  if (platform === "win32") {
+    if (created) {
+      await secureWindowsPrivatePath(path, "directory", "harden", platform, runner);
+    } else {
+      await secureExistingWindowsPath(
+        path,
+        "directory",
+        platform,
+        runner,
+        defaultRoot
+      );
+    }
+    return;
+  }
+  if ((after.mode & 63) !== 0) {
+    throw new Error("Inference host state directory must have mode 0700.");
+  }
+  if (typeof process.getuid === "function" && after.uid !== process.getuid()) {
+    throw new Error("Inference host state directory must be owned by the current user.");
+  }
+  const canonical = await realpath(path);
+  if (canonical !== resolve(path)) {
+    throw new Error("Inference host state directory may not traverse symbolic links.");
+  }
+}
+async function syncInferenceDirectory(path, platform = process.platform) {
+  if (platform === "win32") return;
+  const handle = await open(path, constants.O_RDONLY | constants.O_DIRECTORY);
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+var WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EACCES",
+  "EBUSY",
+  "EEXIST",
+  "ENOTEMPTY",
+  "EPERM"
+]);
+async function replaceAtomicInferencePrivateFile(temporaryPath, destinationPath, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const renameFile = options.renameFile ?? rename;
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve4) => setTimeout(resolve4, milliseconds)));
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 40);
+  const retryDelayMs = Math.max(0, options.retryDelayMs ?? 25);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      await renameFile(temporaryPath, destinationPath);
+      return;
+    } catch (error) {
+      const code = String(error.code ?? "");
+      if (platform !== "win32" || !WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES.has(code) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      await sleep(retryDelayMs);
+    }
+  }
+}
+async function writeAtomicInferencePrivateFile(path, contents, dependencies = {}) {
+  const platform = dependencies.platform ?? process.platform;
+  const runner = dependencies.runner ?? runWindowsPrivateAcl;
+  const defaultRoot = dependencies.defaultRoot ?? resolve(homedir(), ".vtx", "inference-host");
+  const directory = dirname(path);
+  await ensureInferencePrivateDirectory(directory, dependencies);
+  const hardenedDirectoryIdentity = platform === "win32" && isDefaultWindowsPrivatePath(directory, defaultRoot) ? windowsAclCache.get(aclCacheKey(directory, "directory", "harden")) : void 0;
+  if (platform === "win32" && isDefaultWindowsPrivatePath(directory, defaultRoot) && !hardenedDirectoryIdentity) {
+    throw new Error("Windows private directory ACL hardening was not durably verified.");
+  }
+  const temporary = join(
+    directory,
+    `.${process.pid}.${randomBytes(12).toString("hex")}.tmp`
+  );
+  const handle = await open(
+    temporary,
+    constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+    384
+  );
+  try {
+    await handle.writeFile(contents, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    await rm(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+  await handle.close();
+  await secureWindowsPrivatePath(temporary, "file", "harden", platform, runner);
+  const hardenedIdentity = platform === "win32" ? windowsAclCache.get(aclCacheKey(temporary, "file", "harden")) : void 0;
+  if (platform === "win32" && !hardenedIdentity) {
+    await rm(temporary, { force: true }).catch(() => void 0);
+    throw new Error("Windows private ACL hardening was not durably verified.");
+  }
+  try {
+    invalidateWindowsAclCache(path);
+    await replaceAtomicInferencePrivateFile(temporary, path, {
+      platform,
+      renameFile: dependencies.renameFile,
+      sleep: dependencies.sleep,
+      maxAttempts: dependencies.replaceMaxAttempts,
+      retryDelayMs: dependencies.replaceRetryDelayMs
+    });
+    if (platform === "win32" && hardenedIdentity) {
+      await rebindHardenedWindowsAclAfterRename(
+        temporary,
+        path,
+        "file",
+        hardenedIdentity
+      );
+    } else {
+      invalidateWindowsAclCache(temporary);
+    }
+    await syncInferenceDirectory(directory, platform);
+    if (platform === "win32" && hardenedDirectoryIdentity) {
+      await rebindHardenedWindowsDirectoryAfterOwnedMutation(
+        directory,
+        hardenedDirectoryIdentity
+      );
+    }
+  } catch (error) {
+    await rm(temporary, { force: true }).catch(() => void 0);
+    invalidateWindowsAclCache(temporary);
+    throw error;
+  }
+}
+async function acquireInferenceHostProcessLock(path, dependencies = {}) {
+  const directory = dirname(path);
+  await ensureInferencePrivateDirectory(directory);
+  const ownerToken = randomBytes(24).toString("base64url");
+  const observeIdentity = dependencies.processIdentity ?? defaultProcessIdentity;
+  const currentBootIdentity = dependencies.currentBootIdentity ?? (() => readInferenceSystemBootIdentity());
+  const isProcessAlive = dependencies.processAlive ?? ((pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      if (error.code === "ESRCH") return false;
+      throw error;
+    }
+  });
+  let handle;
+  for (let acquisition = 0; acquisition < 2; acquisition += 1) {
+    try {
+      handle = await open(
+        path,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+        384
+      );
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (acquisition > 0) {
+        throw new Error("Another inference host process already owns this local host.");
+      }
+      let before;
+      try {
+        before = await lstat(path);
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        throw error2;
+      }
+      if (before.isSymbolicLink() || !before.isFile() || process.platform !== "win32" && (before.mode & 63) !== 0 || typeof process.getuid === "function" && before.uid !== process.getuid()) {
+        throw new Error("Inference host process lock is unsafe.");
+      }
+      const reclaimPublicationResidue = async () => {
+        let current2;
+        try {
+          current2 = await lstat(path);
+        } catch (error2) {
+          if (error2.code === "ENOENT") return false;
+          throw error2;
+        }
+        if (current2.isSymbolicLink() || !current2.isFile() || current2.dev !== before.dev || current2.ino !== before.ino || process.platform !== "win32" && (current2.mode & 63) !== 0 || typeof process.getuid === "function" && current2.uid !== process.getuid()) {
+          throw new Error("Inference host process lock publication residue changed or is unsafe.");
+        }
+        try {
+          await rm(path);
+        } catch (error2) {
+          if (error2.code === "ENOENT") return false;
+          throw error2;
+        }
+        processLockObservationCache.delete(resolve(path));
+        await syncInferenceDirectory(directory);
+        return true;
+      };
+      try {
+        await secureExistingWindowsPath(path, "file");
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        throw error2;
+      }
+      let staleOwner;
+      try {
+        staleOwner = JSON.parse(await readFile(path, "utf8"));
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        if (Date.now() - before.mtimeMs < 1e4) {
+          throw new Error("Another inference host process already owns this local host.");
+        }
+        await reclaimPublicationResidue();
+        continue;
+      }
+      if (staleOwner.schema_version !== 2 || !Number.isSafeInteger(staleOwner.pid) || Number(staleOwner.pid) < 1 || typeof staleOwner.owner_token !== "string" || !staleOwner.owner_token || typeof staleOwner.process_identity !== "string" || !staleOwner.process_identity || typeof staleOwner.boot_identity !== "string" || !staleOwner.boot_identity) {
+        if (Date.now() - before.mtimeMs < 1e4) {
+          throw new Error("Another inference host process already owns this local host.");
+        }
+        await reclaimPublicationResidue();
+        continue;
+      }
+      const stalePid = Number(staleOwner.pid);
+      const bootIdentity2 = await currentBootIdentity();
+      if (bootIdentity2 === staleOwner.boot_identity && isProcessAlive(stalePid)) {
+        const cached = processLockObservationCache.get(resolve(path));
+        const observedIdentity = cached && cached.dev === before.dev && cached.ino === before.ino && cached.pid === stalePid && cached.storedIdentity === staleOwner.process_identity && Date.now() - cached.observedAtMs < 5e3 ? cached.observedIdentity : await observeIdentity(stalePid);
+        if (!observedIdentity) {
+          throw new Error("Inference host could not verify the existing lock owner identity.");
+        }
+        processLockObservationCache.set(resolve(path), {
+          dev: before.dev,
+          ino: before.ino,
+          pid: stalePid,
+          storedIdentity: staleOwner.process_identity,
+          observedIdentity,
+          observedAtMs: Date.now()
+        });
+        if (inferenceProcessIdentitiesMatch(staleOwner.process_identity, observedIdentity)) {
+          throw new Error("Another inference host process already owns this local host.");
+        }
+      }
+      let current;
+      try {
+        current = await lstat(path);
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        throw error2;
+      }
+      if (current.dev !== before.dev || current.ino !== before.ino) {
+        throw new Error("Inference host process lock ownership changed.");
+      }
+      await rm(path);
+      processLockObservationCache.delete(resolve(path));
+      await syncInferenceDirectory(directory);
+    }
+  }
+  if (!handle) throw new Error("Inference host process lock could not be acquired.");
+  let ownerIdentity;
+  let bootIdentity;
+  try {
+    [ownerIdentity, bootIdentity] = await Promise.all([
+      (dependencies.currentProcessIdentity ?? defaultCurrentProcessIdentity)(),
+      currentBootIdentity()
+    ]);
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    await rm(path, { force: true }).catch(() => void 0);
+    throw error;
+  }
+  await handle.writeFile(
+    `${JSON.stringify({
+      schema_version: 2,
+      pid: process.pid,
+      owner_token: ownerToken,
+      process_identity: ownerIdentity,
+      boot_identity: bootIdentity
+    })}
+`,
+    "utf8"
+  );
+  await handle.sync();
+  await handle.close();
+  await secureWindowsPrivatePath(path, "file", "harden");
+  await syncInferenceDirectory(directory);
+  let released = false;
+  return {
+    path,
+    ownerToken,
+    release: async () => {
+      if (released) return;
+      const metadata = await lstat(path);
+      if (metadata.isSymbolicLink() || !metadata.isFile()) {
+        throw new Error("Inference host process lock is unsafe.");
+      }
+      const parsed = JSON.parse(await readFile(path, "utf8"));
+      if (parsed.owner_token !== ownerToken) {
+        throw new Error("Inference host process lock ownership changed.");
+      }
+      await rm(path);
+      processLockObservationCache.delete(resolve(path));
+      await syncInferenceDirectory(directory);
+      released = true;
+    }
+  };
+}
+
+// lib/inference-host/service-launcher-state.ts
+import { access, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+var launcherSibling = (manifest, suffix) => {
+  if (!manifest.endsWith(".service.json")) throw new Error("Invalid service manifest path.");
+  return `${manifest.slice(0, -".service.json".length)}${suffix}`;
+};
+var within = (parent, child) => {
+  const part = relative2(resolve2(parent), resolve2(child));
+  return Boolean(part) && !part.startsWith("..") && !isAbsolute2(part);
+};
+var launcherSelection = (manifest, value) => {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (r.schema_version !== "vtx_inference_service_release_v1" || r.package_name !== "@vtxmacro/cli" || typeof r.package_version !== "string" || !/^\d{4}\.\d{1,2}\.\d{1,3}$/u.test(r.package_version) || typeof r.integrity !== "string" || typeof r.selected_at !== "string" || !Number.isFinite(Date.parse(r.selected_at)) || typeof r.script !== "string" || !isAbsolute2(r.script) || /[\r\n\0]/u.test(r.script) || !within(launcherSibling(manifest, ".service-releases"), r.script)) return null;
+  return r;
+};
+var readLauncherSelection = async (manifest) => {
+  try {
+    return launcherSelection(manifest, JSON.parse(await readFile2(launcherSibling(manifest, ".service-release.json"), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+var writeLauncherSelection = async (manifest, selection) => {
+  const path = launcherSibling(manifest, ".service-release.json");
+  if (selection) await writeAtomicInferencePrivateFile(path, `${JSON.stringify(selection)}
+`);
+  else await rm2(path, { force: true });
+};
+var readLauncherState = async (manifest) => {
+  let value;
+  try {
+    value = JSON.parse(await readFile2(launcherSibling(manifest, ".service-launcher.json"), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  if (!value || typeof value !== "object") throw new Error("Invalid service launcher state.");
+  const r = value;
+  const target = (v) => {
+    if (!v || typeof v !== "object") return false;
+    const t = v;
+    return typeof t.package_version === "string" && /^\d{4}\.\d{1,2}\.\d{1,3}$/u.test(t.package_version) && typeof t.script === "string" && isAbsolute2(t.script) && !/[\r\n\0]/u.test(t.script) && (within(launcherSibling(manifest, ".service-releases"), t.script) || resolve2(t.script) === resolve2(launcherSibling(manifest, ".service-bootstrap.previous.js"))) && (t.selection === null || (() => {
+      const selected = launcherSelection(manifest, t.selection);
+      return Boolean(selected && selected.package_version === t.package_version && (resolve2(t.script) === resolve2(join2(dirname2(selected.script), "vtx-service-bootstrap.js")) || resolve2(t.script) === resolve2(launcherSibling(manifest, ".service-bootstrap.previous.js"))));
+    })());
+  };
+  if (r.schema_version !== "vtx_inference_service_launcher_v1" || !target(r.active) || r.previous !== null && !target(r.previous) || typeof r.pending !== "boolean") {
+    throw new Error("Invalid service launcher recovery targets.");
+  }
+  return r;
+};
+var writeLauncherState = async (manifest, state) => {
+  await writeAtomicInferencePrivateFile(launcherSibling(manifest, ".service-launcher.json"), `${JSON.stringify(state)}
+`);
+};
+var targetForSelection = async (selection) => {
+  const script = join2(dirname2(selection.script), "vtx-service-bootstrap.js");
+  await access(script);
+  return { package_version: selection.package_version, script, selection };
+};
+
+// lib/inference-host/service-launcher.ts
+var runInferenceHostServiceLauncher = async (manifestPathValue, lockPathValue, dependencies = {}) => {
+  const manifestPath = resolve3(manifestPathValue);
+  const lock = await acquireInferenceHostProcessLock(launcherSibling(manifestPath, ".service-launcher.lock"));
+  const lifetime = new AbortController();
+  let child = null;
+  const stop = () => {
+    lifetime.abort();
+    child?.requestDrain();
+  };
+  dependencies.signal?.addEventListener("abort", stop, { once: true });
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  if (dependencies.signal?.aborted) stop();
+  const desired = async () => {
+    if (lifetime.signal.aborted) return false;
+    const value = JSON.parse(await readFile3(launcherSibling(manifestPath, ".service-desired.json"), "utf8"));
+    return value.schema_version === "vtx_inference_service_desired_v1" && value.desired_running === true;
+  };
+  let manifest;
+  const log = async (event, version) => {
+    await appendFile(manifest.log_path, `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), event, package_version: version })}
+`, { mode: 384 }).catch(() => void 0);
+  };
+  const runCore = dependencies.runCore ?? ((executable, target, args) => {
+    const processChild = spawn2(executable, [target.script, ...args], {
+      windowsHide: true,
+      stdio: ["ignore", "inherit", "inherit", "ipc"],
+      env: { ...process.env, VTX_INFERENCE_HOST_LAUNCHER_PROTOCOL: "1" }
+    });
+    const ready = new Promise((readyResolve) => {
+      processChild.on("message", (message) => {
+        if (message && typeof message === "object" && message.type === "vtx-inference-host-bootstrap-ready-v1" && message.package_version === target.package_version) readyResolve();
+      });
+    });
+    const completion = new Promise((complete) => {
+      processChild.once("error", () => complete(1));
+      processChild.once("exit", (code) => complete(code ?? 1));
+    });
+    return { completion, ready, requestDrain: () => {
+      if (processChild.connected) processChild.send({ type: "vtx-inference-host-launcher-stop-v1" }, () => void 0);
+    }, terminate: () => {
+      processChild.kill("SIGKILL");
+    } };
+  });
+  const drainCore = async (running) => {
+    running.requestDrain();
+    let timer;
+    const exited = await Promise.race([
+      running.completion.then((code) => ({ code })),
+      new Promise((done) => {
+        timer = setTimeout(
+          () => done(null),
+          dependencies.stopTimeoutMs ?? runtime_policy_generated_default.external_inference.service.bootstrap_stop_timeout_ms
+        );
+      })
+    ]).finally(() => clearTimeout(timer));
+    if (exited) return exited.code;
+    running.terminate();
+    return await running.completion;
+  };
+  try {
+    manifest = JSON.parse(await readFile3(manifestPath, "utf8"));
+    let state = await readLauncherState(manifestPath);
+    if (!state) throw new Error("Service launcher recovery state is missing.");
+    const rollback = async (reason) => {
+      if (!state.previous || !await desired()) return false;
+      const failed = state.active;
+      await writeLauncherSelection(manifestPath, state.previous.selection);
+      await writeAtomicInferencePrivateFile(launcherSibling(manifestPath, ".service-release-rejection.json"), `${JSON.stringify({
+        schema_version: "vtx_inference_service_release_rejection_v1",
+        package_version: failed.package_version,
+        rejected_at: (/* @__PURE__ */ new Date()).toISOString(),
+        reason
+      })}
+`);
+      state = { ...state, active: state.previous, previous: null, pending: false };
+      await writeLauncherState(manifestPath, state);
+      await log("service_launcher_rolled_back", failed.package_version);
+      return true;
+    };
+    if (state.pending && state.previous && await desired()) await rollback("bootstrap_interrupted_before_readiness");
+    while (await desired()) {
+      state.pending = true;
+      await writeLauncherState(manifestPath, state);
+      if (!await desired()) return 0;
+      const launchedAt = Date.now();
+      const runtimePath = launcherSibling(manifestPath, ".service-runtime.json");
+      await rm3(runtimePath, { force: true });
+      if (!await desired()) return 0;
+      child = runCore(manifest.executable, state.active, ["--service-manifest", manifestPath, "--service-lock", resolve3(lockPathValue)]);
+      const readiness = new AbortController();
+      const watchingStop = new AbortController();
+      const stopped = (async () => {
+        while (!watchingStop.signal.aborted) {
+          if (!await desired()) return { kind: "stop", code: 0 };
+          await new Promise((done) => {
+            if (watchingStop.signal.aborted) {
+              done();
+              return;
+            }
+            const timer2 = setTimeout(finish, runtime_policy_generated_default.external_inference.service.startup_poll_interval_ms);
+            function finish() {
+              clearTimeout(timer2);
+              watchingStop.signal.removeEventListener("abort", finish);
+              done();
+            }
+            watchingStop.signal.addEventListener("abort", finish, { once: true });
+          });
+        }
+        return await new Promise(() => void 0);
+      })();
+      const legacyReady = async () => {
+        if (resolve3(state.active.script) !== resolve3(launcherSibling(manifestPath, ".service-bootstrap.previous.js"))) {
+          return await new Promise(() => void 0);
+        }
+        while (!readiness.signal.aborted) {
+          try {
+            const currentManifest = JSON.parse(await readFile3(manifestPath, "utf8"));
+            const runtime = JSON.parse(await readFile3(runtimePath, "utf8"));
+            const names = (currentManifest.workers ?? [{ instance_name: "default" }]).map((w) => w.instance_name).sort();
+            if (runtime.schema_version === "vtx_inference_service_runtime_v1" && runtime.manifest_generation === currentManifest.generation && Date.parse(runtime.updated_at) >= launchedAt && Array.isArray(runtime.workers) && runtime.workers.length > 0 && runtime.workers.every((w) => w.state === "running") && JSON.stringify(runtime.workers.map((w) => w.instance_name).sort()) === JSON.stringify(names)) return;
+          } catch {
+          }
+          await new Promise((r) => {
+            if (readiness.signal.aborted) {
+              r();
+              return;
+            }
+            const timer2 = setTimeout(done, 100);
+            function done() {
+              clearTimeout(timer2);
+              readiness.signal.removeEventListener("abort", done);
+              r();
+            }
+            readiness.signal.addEventListener("abort", done, { once: true });
+          });
+        }
+        return await new Promise(() => void 0);
+      };
+      let timer;
+      let first;
+      let code;
+      try {
+        first = await Promise.race([
+          Promise.race([child.ready, legacyReady()]).then(() => ({ kind: "ready", code: 0 })),
+          child.completion.then((code2) => ({ kind: "exit", code: code2 })),
+          stopped,
+          new Promise((r) => {
+            timer = setTimeout(() => r({ kind: "timeout", code: 1 }), dependencies.readyTimeoutMs ?? runtime_policy_generated_default.external_inference.service.bootstrap_readiness_timeout_ms);
+          })
+        ]).finally(() => {
+          clearTimeout(timer);
+          readiness.abort();
+        });
+        if (first.kind === "ready") {
+          const selected = await readLauncherSelection(manifestPath);
+          if (selected?.package_version === state.active.package_version) state.active = { ...state.active, selection: selected };
+          state.pending = false;
+          await writeLauncherState(manifestPath, state);
+          await log("service_launcher_ready", state.active.package_version);
+        }
+        if (first.kind === "exit") code = first.code;
+        else if (first.kind !== "ready") code = await drainCore(child);
+        else {
+          const finished = await Promise.race([child.completion.then((code2) => ({ kind: "exit", code: code2 })), stopped]);
+          code = finished.kind === "exit" ? finished.code : await drainCore(child);
+        }
+      } finally {
+        watchingStop.abort();
+        readiness.abort();
+        clearTimeout(timer);
+      }
+      child = null;
+      const supervisorLockPath = resolve3(lockPathValue).replace(/\.service-bootstrap$/u, ".service");
+      if (supervisorLockPath !== resolve3(lockPathValue)) {
+        while (true) {
+          try {
+            const supervisorLock = await acquireInferenceHostProcessLock(supervisorLockPath);
+            await supervisorLock.release();
+            break;
+          } catch (error) {
+            if (!/already owns/iu.test(error instanceof Error ? error.message : "")) throw error;
+            await new Promise((r) => setTimeout(r, 100));
+          }
+        }
+      }
+      if (!await desired()) return 0;
+      if (code === 75) {
+        const selected = await readLauncherSelection(manifestPath);
+        if (selected && selected.package_version !== state.active.package_version) {
+          let next;
+          try {
+            next = await targetForSelection(selected);
+          } catch {
+            await writeLauncherSelection(manifestPath, state.active.selection);
+            await writeAtomicInferencePrivateFile(launcherSibling(manifestPath, ".service-release-rejection.json"), `${JSON.stringify({
+              schema_version: "vtx_inference_service_release_rejection_v1",
+              package_version: selected.package_version,
+              rejected_at: (/* @__PURE__ */ new Date()).toISOString(),
+              reason: "bootstrap_core_missing"
+            })}
+`);
+            state.pending = false;
+            await writeLauncherState(manifestPath, state);
+            continue;
+          }
+          state = { schema_version: state.schema_version, active: next, previous: state.active, pending: false };
+          await writeLauncherState(manifestPath, state);
+          await log("service_launcher_handoff", next.package_version);
+          continue;
+        }
+      }
+      if (!await rollback(first.kind === "timeout" ? "bootstrap_readiness_timeout" : "bootstrap_exited")) return code || 1;
+    }
+    return 0;
+  } finally {
+    lifetime.abort();
+    if (child) await drainCore(child).catch(() => 1);
+    dependencies.signal?.removeEventListener("abort", stop);
+    process.removeListener("SIGTERM", stop);
+    process.removeListener("SIGINT", stop);
+    await lock.release();
+  }
+};
+var invokedPath = process.argv[1] ? resolve3(process.argv[1]) : "";
+if (invokedPath === fileURLToPath(import.meta.url)) {
+  const manifestIndex = process.argv.indexOf("--service-manifest");
+  const lockIndex = process.argv.indexOf("--service-lock");
+  const manifest = manifestIndex >= 0 ? process.argv[manifestIndex + 1] : null;
+  const lock = lockIndex >= 0 ? process.argv[lockIndex + 1] : null;
+  if (!manifest || !lock) {
+    process.stderr.write("Internal service manifest and lock paths are required.\n");
+    process.exitCode = 1;
+  } else process.exitCode = await runInferenceHostServiceLauncher(manifest, lock).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "Service launcher failed."}
+`);
+    return 1;
+  });
+}
+export {
+  runInferenceHostServiceLauncher
+};
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/