@rallycry/conveyor-k3 0.1.8 → 0.1.11

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PersonalClusterEnrollmentBundle, PersonalClusterEnrollmentCompletion, PersonalClusterDesiredState, PersonalClusterHeartbeat, PersonalClusterKubeletState } from '@project/shared';
+import { PersonalClusterEnrollmentBundle, PersonalClusterEnrollmentCompletion, PersonalClusterDesiredState, PersonalClusterHeartbeat, PersonalClusterWorkloads, PersonalClusterKubeletState } from '@project/shared';
 
 interface ClusterConnectionConfig {
     apiUrl: string;
@@ -19,8 +19,8 @@ declare class ClusterConnection {
     enroll(): Promise<PersonalClusterEnrollmentBundle>;
     completeEnrollment(payload: PersonalClusterEnrollmentCompletion): Promise<void>;
     requestDesiredState(): Promise<PersonalClusterDesiredState>;
-    /** Fire-and-forget: a lost heartbeat is covered by the next one. */
-    sendHeartbeat(payload: PersonalClusterHeartbeat): void;
+    /** Old servers still receive liveness even when they do not acknowledge inspection data. */
+    sendHeartbeat(payload: PersonalClusterHeartbeat): Promise<PersonalClusterWorkloads | undefined>;
     /**
      * Tell Conveyor this machine is stopping, so placement skips it at once
      * instead of waiting out the stale window.
@@ -83,6 +83,7 @@ interface DaemonPorts {
     fs: FileSystemPort$1;
     connection: ClusterConnection;
     cliVersion: string;
+    writeWorkloads?: (data: PersonalClusterWorkloads | undefined) => Promise<void>;
     log: (line: string) => void;
 }
 declare class ClusterDaemon {
@@ -150,7 +151,11 @@ declare class ClusterDaemon {
     private strandedBytesExceedLimit;
     prune(): Promise<void>;
     private buildHeartbeat;
+    private persistWorkloads;
+    private beating?;
+    private stopped;
     beat(): Promise<void>;
+    private runBeat;
 }
 
 /**
@@ -710,6 +715,7 @@ interface GuestSrvRecord {
     weight: number;
 }
 interface ResolvedNetwork {
+    publicWeb?: boolean;
     hosts: ResolvedNetworkHost[];
     /** Static SRV answers needed by cloudflared's documented edge discovery. */
     srv: GuestSrvRecord[];
@@ -774,4 +780,7 @@ interface QemuPolicyContext {
 /** Rewrites only a complete, known Lima QEMU profile; every unknown input fails closed. */
 declare function rewriteQemuArgs(args: string[], network: QemuNetworkPolicy, ncPath?: string, context?: QemuPolicyContext): string[];
 
-export { ClusterConnection, type ClusterConnectionConfig, ClusterDaemon, CommandError, type CrictlImage, type DaemonPorts, type Executor, type FileSystemPort$1 as FileSystemPort, type GuestDnsProvision, type GuestSrvRecord, HELP, type ImageInventory, K3S_DISABLED_COMPONENTS, K3S_INSTALL_EXEC, type K3sUpgradeDecision, type MachineState, type NetworkEndpoint, type NetworkPolicy, type QemuNetworkPolicy, type ReconcileContext, type ReconcileResult, type RegistriesFile, type ResolvedNetwork, type ResolvedNetworkHost, type SRVLookup, type UninstallResult, type UnitRenderOptions, VERBS, type Verb, cloudflaredSrvRecords, collectHeartbeat, configuredAuthHosts, countRunningConveyorPods, createMemoryFileSystem, decideK3sUpgrade, isGloballyRoutableIPv4, isVerb, meetsK3sMinimum, missingAuthHosts, nodeFileSystem, ownerConfiguredKeys, ownerConfiguredKubeletFlags, parseArgs, parseK3sVersion, parseRegistries, pruneStrandedImages, readImageInventory, readState, reconcile, registryAdd, registryList, renderAllUnits, renderGuestDnsProvision, renderK3sDropIn, renderKubeletDropIn, renderRegistryAuthSummary, resolveCloudflaredSrvRecords, resolveNetwork, rewriteQemuArgs, runOrThrow, runUpdate, selectStrandedImages, serializeRegistries, spawnExecutor, uninstall, upsertRegistryAuth, warmImages, writeState };
+/** Reserve 25% of physical host RAM after accounting for VM overhead. */
+declare function maximumGuestMemoryGiB(hostBytes: number): number;
+
+export { ClusterConnection, type ClusterConnectionConfig, ClusterDaemon, CommandError, type CrictlImage, type DaemonPorts, type Executor, type FileSystemPort$1 as FileSystemPort, type GuestDnsProvision, type GuestSrvRecord, HELP, type ImageInventory, K3S_DISABLED_COMPONENTS, K3S_INSTALL_EXEC, type K3sUpgradeDecision, type MachineState, type NetworkEndpoint, type NetworkPolicy, type QemuNetworkPolicy, type ReconcileContext, type ReconcileResult, type RegistriesFile, type ResolvedNetwork, type ResolvedNetworkHost, type SRVLookup, type UninstallResult, type UnitRenderOptions, VERBS, type Verb, cloudflaredSrvRecords, collectHeartbeat, configuredAuthHosts, countRunningConveyorPods, createMemoryFileSystem, decideK3sUpgrade, isGloballyRoutableIPv4, isVerb, maximumGuestMemoryGiB, meetsK3sMinimum, missingAuthHosts, nodeFileSystem, ownerConfiguredKeys, ownerConfiguredKubeletFlags, parseArgs, parseK3sVersion, parseRegistries, pruneStrandedImages, readImageInventory, readState, reconcile, registryAdd, registryList, renderAllUnits, renderGuestDnsProvision, renderK3sDropIn, renderKubeletDropIn, renderRegistryAuthSummary, resolveCloudflaredSrvRecords, resolveNetwork, rewriteQemuArgs, runOrThrow, runUpdate, selectStrandedImages, serializeRegistries, spawnExecutor, uninstall, upsertRegistryAuth, warmImages, writeState };

package/dist/index.js

@@ -4109,12 +4109,12 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-3D2OVVIS.js
-var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+// ../shared/dist/chunk-PVMC53P5.js
+var DEFAULT_SONNET_MODEL = "claude-sonnet-5-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5-5";
 var DEFAULT_HAIKU_MODEL = "claude-haiku-4-5-20251001";
 var FABLE_MODEL = "claude-fable-5-1";
-var PREVIOUS_SONNET_MODEL = "claude-sonnet-4-6";
+var PREVIOUS_SONNET_MODEL = "claude-sonnet-5";
 var PREVIOUS_OPUS_MODEL = "claude-opus-5";
 function formatModelId(provider, model) {
   return `${provider}/${model}`;
@@ -6175,8 +6175,8 @@ function anthropicEntry(model, label, inputPerMillion, outputPerMillion, opts =
 var ANTHROPIC_CATALOG = [
   anthropicEntry(DEFAULT_OPUS_MODEL, "Opus 5.5 Latest", 4, 20),
   anthropicEntry(PREVIOUS_OPUS_MODEL, "Opus 5", 5, 25),
-  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5 Latest", 3, 15),
-  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 4.6", 3, 15),
+  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5.5 Latest", 2, 10),
+  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 5", 2, 10),
   // The Haiku line (4.5 and older) predates the tuning surface and 400s on it.
   anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 1, 5, { supportsEffort: false }),
   anthropicEntry(FABLE_MODEL, "Fable 5.1", 10, 50)
@@ -6611,9 +6611,16 @@ var ClusterConnection = class {
     const ack = await this.require().timeout(3e4).emitWithAck(PERSONAL_CLUSTER_EVENTS.requestDesiredState, {});
     return unwrap(ack, "Fetching settings");
   }
-  /** Fire-and-forget: a lost heartbeat is covered by the next one. */
-  sendHeartbeat(payload) {
-    this.socket?.emit(PERSONAL_CLUSTER_EVENTS.heartbeat, payload);
+  /** Old servers still receive liveness even when they do not acknowledge inspection data. */
+  async sendHeartbeat(payload) {
+    if (!this.socket?.connected) return void 0;
+    try {
+      const ack = await this.socket.timeout(8e3).emitWithAck(PERSONAL_CLUSTER_EVENTS.heartbeat, payload);
+      if (!this.socket?.connected) return void 0;
+      return unwrap(ack, "Reading pod assignments");
+    } catch {
+      return void 0;
+    }
   }
   /**
    * Tell Conveyor this machine is stopping, so placement skips it at once
@@ -7398,6 +7405,7 @@ async function collectHeartbeat(ports, state, inventory) {
   const runnerUsers = await detectRunnerUsers(ports.exec);
   const ungranted = ungrantedRunnerUsers(runnerUsers, await ports.readFile(RUNNERS_SUDOERS_FILE));
   return {
+    publicWebProxy: (await ports.readFile("/etc/conveyor-vm/public-web"))?.trim() === "enabled",
     cliVersion: state.cliVersion,
     k3sVersion: await versionOf(ports.exec, "k3s", ["--version"]),
     cloudflaredVersion: await versionOf(ports.exec, "cloudflared", ["--version"]),
@@ -7420,6 +7428,31 @@ async function collectHeartbeat(ports, state, inventory) {
     ]
   };
 }
+async function readPodIdentities(exec) {
+  const result = await exec(
+    "k3s",
+    [
+      "kubectl",
+      "get",
+      "pods",
+      "-A",
+      "-l",
+      CONVEYOR_POD_SELECTOR,
+      "--request-timeout=5s",
+      "--no-headers",
+      "-o",
+      "custom-columns=NS:.metadata.namespace,NAME:.metadata.name,UID:.metadata.uid"
+    ],
+    { timeoutMs: 7e3, maxOutputBytes: 65536 }
+  );
+  if (result.exitCode !== 0) return [];
+  const rows = result.stdout.trim().split("\n").filter(Boolean);
+  if (rows.length > 100) return [];
+  return rows.flatMap((row) => {
+    const [namespace, name, uid, extra] = row.trim().split(/\s+/);
+    return !extra && [namespace, name, uid].every((s) => s && /^[a-zA-Z0-9][a-zA-Z0-9.-]{0,252}$/.test(s)) ? [{ namespace, name, uid }] : [];
+  });
+}
 
 // src/daemon/runner.ts
 var HOUR_MS = 60 * 6e4;
@@ -7489,10 +7522,13 @@ var ClusterDaemon = class {
     await this.beat();
   }
   async stop() {
+    this.stopped = true;
     for (const timer of this.timers) clearInterval(timer);
     this.timers = [];
     await this.ports.connection.sayGoodbye();
     this.ports.connection.disconnect();
+    await this.beating;
+    await this.persistWorkloads(void 0);
   }
   /** Fetch the desired state and converge to it. Queued, never concurrent. */
   syncAndReconcile() {
@@ -7654,10 +7690,33 @@ var ClusterDaemon = class {
       inventory
     );
   }
-  async beat() {
+  async persistWorkloads(data) {
     try {
-      this.ports.connection.sendHeartbeat(await this.buildHeartbeat());
+      await this.ports.writeWorkloads?.(data);
     } catch (error) {
+      this.ports.log(
+        `Pod context cache unavailable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  beating;
+  stopped = false;
+  beat() {
+    if (this.stopped) return Promise.resolve();
+    this.beating ??= this.runBeat().finally(() => {
+      this.beating = void 0;
+    });
+    return this.beating;
+  }
+  async runBeat() {
+    try {
+      const workloads = await this.ports.connection.sendHeartbeat({
+        ...await this.buildHeartbeat(),
+        observedPods: await readPodIdentities(this.ports.exec).catch(() => [])
+      });
+      if (!this.stopped) await this.persistWorkloads(workloads);
+    } catch (error) {
+      await this.persistWorkloads(void 0);
       this.ports.log(`Heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -7723,6 +7782,7 @@ Documentation=https://conveyor.rallycryapp.com/docs/guides/managed-personal-comp
 
 [Service]
 Type=oneshot
+User=root
 EnvironmentFile=${ENV_FILE}
 ExecStart=${options.cliBin} update
 StandardOutput=journal
@@ -8448,6 +8508,13 @@ while True:
                 udp.sendto(response, peer)
 `;
 
+// src/vm/public-web.ts
+import { resolve4 } from "dns/promises";
+import { networkInterfaces as networkInterfaces2 } from "os";
+var PUBLIC_WEB_IP = "192.168.5.250";
+var PUBLIC_WEB_PORT = 3128;
+var PUBLIC_WEB_URL = `http://${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}`;
+
 // src/vm/qemu-policy.ts
 var ALLOWED_PROBES = new Set(
   [
@@ -8684,7 +8751,10 @@ function restrictedUsernet(network, forwards, ncPath) {
     "restrict=on",
     "ipv6=off",
     `hostfwd=tcp:127.0.0.1:${network.sshPort}-:22`,
-    ...guestForwards
+    ...guestForwards,
+    ...network.publicWeb === true ? [
+      `guestfwd=tcp:${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}-cmd:${ncPath} -4 -n -w 60 public-web ${PUBLIC_WEB_PORT}`
+    ] : []
   ].join(",");
 }
 function validateForwards(forwards) {
@@ -8850,6 +8920,13 @@ function rewriteQemuArgs(args, network, ncPath = "/usr/bin/nc", context = {}) {
   assertCompleteProfile(state);
   return output;
 }
+
+// src/vm/memory-budget.ts
+function maximumGuestMemoryGiB(hostBytes) {
+  if (!Number.isFinite(hostBytes) || hostBytes <= 0) return 0;
+  const budget = hostBytes / 1024 ** 3 * 0.75;
+  return Math.max(0, Math.floor(Math.min(budget - 1, budget / 1.25)));
+}
 export {
   ClusterConnection,
   ClusterDaemon,
@@ -8866,6 +8943,7 @@ export {
   decideK3sUpgrade,
   isGloballyRoutableIPv4,
   isVerb,
+  maximumGuestMemoryGiB,
   meetsK3sMinimum,
   missingAuthHosts,
   nodeFileSystem,

package/dist/vm-qemu.js

@@ -7,6 +7,10 @@ import { dirname, join as join5 } from "path";
 import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 
+// src/vm/public-web.ts
+import { resolve4 } from "dns/promises";
+import { networkInterfaces as networkInterfaces2 } from "os";
+
 // src/vm/network.ts
 import { networkInterfaces } from "os";
 import { resolve4 as systemResolve4, resolveSrv as systemResolveSrv } from "dns/promises";
@@ -50,6 +54,98 @@ function isGloballyRoutableIPv4(address) {
   ].some(([base, mask]) => inCidr(value, parseIPv4(base), mask));
 }
 
+// src/vm/public-web.ts
+var PUBLIC_WEB_IP = "192.168.5.250";
+var PUBLIC_WEB_PORT = 3128;
+var PUBLIC_WEB_URL = `http://${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}`;
+async function publicWebAddress(host, lookup = resolve4, interfaces = networkInterfaces2) {
+  if (!/^[a-z0-9.-]+$/i.test(host) || host.length > 253)
+    throw new Error("Invalid public destination");
+  const own = new Set(
+    Object.values(interfaces()).flatMap((items) => items?.map((i) => i.address) ?? [])
+  );
+  const answers = /^\d+\.\d+\.\d+\.\d+$/.test(host) ? [host] : await lookup(host);
+  if (!answers.length || answers.some((ip) => !isGloballyRoutableIPv4(ip) || own.has(ip)))
+    throw new Error("Host, LAN and reserved destinations are blocked");
+  const address = answers[0];
+  if (!address) throw new Error("No public DNS answer");
+  return address;
+}
+function publicWebRequest(header) {
+  const lines = header.split("\r\n");
+  const match = /^(CONNECT|GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS) ([^\s]+) HTTP\/1\.[01]$/.exec(
+    lines.shift() ?? ""
+  );
+  if (!match) throw new Error("Unsupported proxy request");
+  const connect = match[1] === "CONNECT";
+  const target = match[2] ?? "";
+  if (connect && !/^[a-z0-9.-]+:(80|443)$/i.test(target))
+    throw new Error("Invalid CONNECT destination");
+  const { url, port } = proxyUrl(target, connect);
+  for (const line of lines.filter(Boolean)) {
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+:[\t\x20-\x7e]*$/.test(line))
+      throw new Error("Invalid proxy header");
+  }
+  const headers = lines.filter(
+    (line) => line && !/^(host|connection|proxy-connection|proxy-authorization):/i.test(line)
+  );
+  return {
+    host: url.hostname,
+    port,
+    connect,
+    forward: connect ? "" : `${match[1]} ${url.pathname}${url.search} HTTP/1.1\r
+Host: ${url.host}\r
+Connection: close\r
+${headers.length ? headers.join("\r\n") + "\r\n" : ""}\r
+`
+  };
+}
+function readPublicWebRequest(input) {
+  return new Promise((resolve, reject) => {
+    let data = Buffer.alloc(0);
+    const cleanup = () => {
+      clearTimeout(timer);
+      input.pause();
+      input.removeListener("data", receive);
+      input.removeListener("end", closed);
+      input.removeListener("error", failed);
+    };
+    const failed = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const closed = () => failed(new Error("Incomplete proxy request"));
+    const timer = setTimeout(() => failed(new Error("Proxy handshake timed out")), 1e4);
+    const receive = (chunk) => {
+      data = Buffer.concat([data, chunk]);
+      const end = data.indexOf("\r\n\r\n");
+      if (end < 0 && data.length > 16384 || end > 16384)
+        return failed(new Error("Proxy header too large"));
+      if (end < 0) return;
+      cleanup();
+      try {
+        const request = publicWebRequest(data.subarray(0, end).toString("latin1"));
+        const remaining = Buffer.concat([Buffer.from(request.forward), data.subarray(end + 4)]);
+        if (remaining.length) input.unshift(remaining);
+        resolve(request);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    input.on("data", receive);
+    input.once("end", closed);
+    input.once("error", failed);
+  });
+}
+function proxyUrl(target, connect) {
+  const url = new URL(connect ? `https://${target}` : target);
+  if (url.username || url.password || url.hash || !connect && url.protocol !== "http:")
+    throw new Error("Invalid proxy URL");
+  const port = Number(url.port || (connect ? 443 : 80));
+  if (port !== 80 && port !== 443) throw new Error("Only public web ports 80 and 443 are allowed");
+  return { url, port };
+}
+
 // src/vm/qemu-policy.ts
 var ALLOWED_PROBES = new Set(
   [
@@ -286,7 +382,10 @@ function restrictedUsernet(network, forwards, ncPath) {
     "restrict=on",
     "ipv6=off",
     `hostfwd=tcp:127.0.0.1:${network.sshPort}-:22`,
-    ...guestForwards
+    ...guestForwards,
+    ...network.publicWeb === true ? [
+      `guestfwd=tcp:${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}-cmd:${ncPath} -4 -n -w 60 public-web ${PUBLIC_WEB_PORT}`
+    ] : []
   ].join(",");
 }
 function validateForwards(forwards) {
@@ -473,7 +572,7 @@ import { Socket } from "net";
 var MAX_RELAYS = 16;
 var MAX_RELAY_BYTES = 1024 * 1024 * 1024;
 var RELAY_CONNECT_MS = 6e4;
-var RELAY_IDLE_MS = 3e4;
+var RELAY_IDLE_MS = 15 * 6e4;
 var GUARD_FRESH_MS = 6e3;
 var RELAY_PREFIX = "--conveyor-vm-relay";
 function validPid(value) {
@@ -589,7 +688,7 @@ function parseRelayInvocation(args) {
   }
   const address = args[5] ?? "";
   const port = Number(args[6]);
-  if (!isGloballyRoutableIPv4(address) || !Number.isInteger(port) || port < 1 || port > 65535) {
+  if (!(isGloballyRoutableIPv4(address) || address === "public-web" && port === PUBLIC_WEB_PORT) || !Number.isInteger(port) || port < 1 || port > 65535) {
     throw new Error("Invalid VM relay destination");
   }
   return { address, port };
@@ -668,21 +767,53 @@ function currentGuardStillValid(root, runId) {
 function runRelay(root, invocation, io) {
   return Promise.resolve().then(() => runRelayNow(root, invocation, io));
 }
-function runRelayNow(root, invocation, io) {
+async function runRelayNow(root, invocation, io) {
   const guard = readLiveGuard(root);
-  assertApprovedDestination(root, invocation);
+  const publicWeb = invocation.address === "public-web" && invocation.port === PUBLIC_WEB_PORT;
+  if (publicWeb) {
+    if (readNetwork(root).publicWeb !== true) throw new Error("Public web access is not enabled");
+  } else assertApprovedDestination(root, invocation);
   const record = registerRelay(root, guard.runId);
+  const streams = io ?? { socket: new Socket(), input: process.stdin, output: process.stdout };
+  let connectedResponse = false;
+  if (publicWeb) {
+    const releaseHandshake = handshakeExitCleanup(root, record);
+    let timeout;
+    try {
+      const request = await readPublicWebRequest(streams.input);
+      const address = await Promise.race([
+        publicWebAddress(request.host),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error("DNS lookup timed out")), 5e3);
+        })
+      ]);
+      if (!currentGuardStillValid(root, record.runId))
+        throw new Error("Resource guard is no longer healthy");
+      invocation = { address, port: request.port };
+      connectedResponse = request.connect;
+    } catch {
+      unregisterRelay(root, record);
+      streams.output.write(
+        "HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
+      );
+      streams.input.destroy();
+      streams.socket.destroy();
+      return;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      releaseHandshake();
+    }
+  }
+  return transportRelay(root, invocation, streams, record, connectedResponse);
+}
+function transportRelay(root, invocation, streams, record, connectedResponse) {
   return new Promise((resolve) => {
     let finished = false;
     let sent = 0;
     let received = 0;
     let guardTimer;
     let connectTimer;
-    const { socket, input, output } = io ?? {
-      socket: new Socket(),
-      input: process.stdin,
-      output: process.stdout
-    };
+    const { socket, input, output } = streams;
     const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
     const cleanup = () => {
       try {
@@ -714,6 +845,7 @@ function runRelayNow(root, invocation, io) {
     socket.once("connect", () => {
       if (connectTimer) clearTimeout(connectTimer);
       connectTimer = void 0;
+      if (connectedResponse) output.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     });
     socket.on("error", () => finish(new Error("VM relay connection failed")));
     socket.on("close", () => finish());
@@ -741,8 +873,35 @@ function runRelayNow(root, invocation, io) {
       RELAY_CONNECT_MS
     );
     socket.connect(invocation.port, invocation.address);
+    input.resume();
   });
 }
+function handshakeExitCleanup(root, record) {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const cleanup = () => {
+    try {
+      unregisterRelay(root, record);
+    } catch {
+    }
+  };
+  const release = () => {
+    process.removeListener("exit", cleanup);
+    for (const signal of signals) process.removeListener(signal, terminated);
+  };
+  const terminated = (signal) => {
+    cleanup();
+    release();
+    process.kill(process.pid, signal);
+  };
+  process.once("exit", cleanup);
+  for (const signal of signals) process.once(signal, terminated);
+  return release;
+}
+
+// src/vm/memory-budget.ts
+function vmHostMemoryGiB(guestGiB) {
+  return guestGiB + Math.max(1, guestGiB / 4);
+}
 
 // src/vm/resource-guard.ts
 var GIB = 1024 ** 3;
@@ -753,7 +912,9 @@ function guardLimits(resources) {
   }
   return {
     minFreeBytes: 10 * GIB,
-    maxRssKiB: (resources.memoryGiB + 1) * 1024 ** 2,
+    // A 24 GiB Mac guest exceeded 27 GiB during image unpacking. Allow 25%
+    // overhead (at least 1 GiB); admission reserves host RAM using this same cap.
+    maxRssKiB: vmHostMemoryGiB(resources.memoryGiB) * 1024 ** 2,
     maxProcesses: 64,
     maxOutputBytes: 1024 * 1024,
     maxDiskBytes: (resources.diskGiB + 1) * GIB,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-k3",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "description": "Managed personal compute for Conveyor. Installs and maintains a k3s cluster that runs your own card builds, kept converged on Conveyor's desired state.",
   "keywords": [
     "cloudflared",