@forgezero/agent 0.1.74 → 0.1.76

package/dist/fz-agent.js

@@ -3,9 +3,9 @@
 
 // src/index.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync17, existsSync as existsSync21, mkdirSync as mkdirSync17, chmodSync as chmodSync18, lstatSync as lstatSync9, statfsSync as statfsSync2 } from "fs";
-import { cpus, totalmem } from "os";
-import { dirname as dirname12, join as join12 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync18, existsSync as existsSync22, mkdirSync as mkdirSync18, chmodSync as chmodSync18, lstatSync as lstatSync9, statfsSync as statfsSync3 } from "fs";
+import { cpus as cpus2, totalmem as totalmem2 } from "os";
+import { dirname as dirname14, join as join12 } from "path";
 
 // ../access/dist/security.js
 var HEX = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
@@ -4643,7 +4643,7 @@ function safeOp(line) {
 // src/deployment.ts
 import { chmodSync as chmodSync4, existsSync as existsSync4, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, statfsSync, writeFileSync as writeFileSync3 } from "fs";
 import { createHash as createHash5, randomUUID } from "crypto";
-import { dirname, isAbsolute as isAbsolute2, join as join2 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2 } from "path";
 
 // ../runtime/dist/queue.js
 class QueueStoppedError extends Error {
@@ -4953,22 +4953,30 @@ import {
   accessSync,
   chmodSync as chmodSync2,
   copyFileSync,
+  createReadStream,
   existsSync as existsSync2,
   mkdtempSync,
   mkdirSync,
   readFileSync,
   renameSync,
   rmSync,
+  statSync,
   symlinkSync,
   unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { dirname, join } from "path";
 var PINNED_BUN_VERSION = "1.3.14";
 var BUN_RELEASE_SHA256 = "951ee2aee855f08595aeec6225226a298d3fea83a3dcd6465c09cbccdf7e848f";
 var ARANGO_SHA256 = "b5a9197b4343f2ed554e1ebc1ef8e6529c7c39cde0035cdc311a4747a3355066";
 var CLOUDFLARED_SHA256 = "9d71c677db00134c1bd4144b7783486b654ad281b1ea62b4972098d19f770f17";
+var NERDCTL_VERSION = "2.3.5";
+var BUILDKIT_VERSION = "0.32.2";
+var KATA_CONTAINERS_VERSION = "4.0.0";
+var NERDCTL_SHA256 = "de3206aeb7cbd5f20f5fb1f55c1e3bf2db1be567812a8a3f5e65eba2488347ee";
+var BUILDKIT_SHA256 = "2975d0f651ad96ba8b80b9992ae1f9a964f4408569af5b6dc36544165c3926af";
+var KATA_SHA256 = "2c3b9dfeba355582b40aee462b12916c9740654d0230f696adf719d67b063a8c";
 var OS_CATALOG = [
   {
     id: "ubuntu",
@@ -4998,6 +5006,8 @@ var OS_CATALOG = [
 var SOFTWARE_CATALOG = [
   { id: "bun", version: "1.3.14", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "docker", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
+  { id: "containerd", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
+  { id: "kata-containers", version: "4.0.0", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "nginx", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "arangodb", version: "3.11.14", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "cloudflared", version: "2026.7.3", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
@@ -5006,6 +5016,7 @@ var SOFTWARE_CATALOG = [
   { id: "openssh-client", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "git", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "docker", version: "ubuntu-24.04", status: "active", os: "ubuntu", osVersion: "24.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
+  { id: "containerd", version: "ubuntu-24.04", status: "active", os: "ubuntu", osVersion: "24.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "nginx", version: "ubuntu-24.04", status: "active", os: "ubuntu", osVersion: "24.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "ufw", version: "ubuntu-24.04", status: "active", os: "ubuntu", osVersion: "24.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "openssh-client", version: "ubuntu-24.04", status: "active", os: "ubuntu", osVersion: "24.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
@@ -5014,6 +5025,8 @@ var SOFTWARE_CATALOG = [
 var UBUNTU_2604_X64 = [
   { requirement: { id: "bun", version: "1.3.14" } },
   { requirement: { id: "docker", version: "ubuntu-26.04" } },
+  { requirement: { id: "containerd", version: "ubuntu-26.04" } },
+  { requirement: { id: "kata-containers", version: "4.0.0" } },
   { requirement: { id: "nginx", version: "ubuntu-26.04" } },
   { requirement: { id: "arangodb", version: "3.11.14" } },
   { requirement: { id: "cloudflared", version: "2026.7.3" } },
@@ -5025,6 +5038,7 @@ var UBUNTU_2604_X64 = [
 var UBUNTU_2404_X64 = [
   { requirement: { id: "bun", version: "1.3.14" } },
   { requirement: { id: "docker", version: "ubuntu-24.04" } },
+  { requirement: { id: "containerd", version: "ubuntu-24.04" } },
   { requirement: { id: "nginx", version: "ubuntu-24.04" } },
   { requirement: { id: "ufw", version: "ubuntu-24.04" } },
   { requirement: { id: "openssh-client", version: "ubuntu-24.04" } },
@@ -5041,6 +5055,46 @@ var DOCKER_DAEMON_CONFIG = `${JSON.stringify({
   "log-opts": { "max-size": "10m", "max-file": "3" }
 }, null, 2)}
 `;
+var CONTAINERD_CONFIG_PATH = "/etc/containerd/config.toml";
+var KATA_SNP_CONFIG_PATH = "/opt/kata/share/defaults/kata-containers/configuration-qemu-snp.toml";
+var KATA_ACTIVE_CONFIG_PATH = "/etc/kata-containers/configuration.toml";
+var CONTAINERD_CONFIG = (kata) => `version = 2
+root = "/var/lib/forgezero/containerd"
+state = "/run/forgezero/containerd"
+
+[grpc]
+  address = "/run/containerd/containerd.sock"
+
+[plugins."io.containerd.grpc.v1.cri".containerd]
+  snapshotter = "overlayfs"
+  default_runtime_name = "runc"
+
+[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
+  runtime_type = "io.containerd.runc.v2"
+${kata ? `
+[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu-snp]
+  runtime_type = "io.containerd.kata.v2"
+  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu-snp.options]
+    ConfigPath = "${KATA_ACTIVE_CONFIG_PATH}"
+` : ""}`;
+var BUILDKIT_UNIT = `[Unit]
+Description=ForgeZero BuildKit daemon
+After=network-online.target containerd.service
+Wants=network-online.target
+Requires=containerd.service
+
+[Service]
+Type=notify
+ExecStart=/usr/local/bin/buildkitd --addr unix:///run/buildkit/buildkitd.sock --root /var/lib/forgezero/buildkit
+Restart=on-failure
+RestartSec=2
+NoNewPrivileges=yes
+ProtectSystem=strict
+ReadWritePaths=/var/lib/forgezero/buildkit /run/buildkit
+
+[Install]
+WantedBy=multi-user.target
+`;
 var softwareSpawnFailure = (cause, argv) => cause.code === "ENOENT" ? { exitCode: 127, output: `executable is absent: ${argv[0]}` } : undefined;
 var runSoftwareCommand = async (argv, env = {}) => {
   let child;
@@ -5060,14 +5114,28 @@ var runSoftwareCommand = async (argv, env = {}) => {
   return { exitCode, output: `${stdout}${stderr}` };
 };
 var run = runSoftwareCommand;
-var download = async (url, destination, sha2562) => {
-  const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(120000) });
+var download = async (url, destination, sha2562, maximumBytes = 512 * 1024 * 1024) => {
+  const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(30 * 60000) });
   if (!response.ok)
     throw new Error(`download failed with HTTP ${response.status}`);
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  if (createHash("sha256").update(bytes).digest("hex") !== sha2562)
+  const declared = Number(response.headers.get("content-length") ?? 0);
+  if (declared > maximumBytes)
+    throw new Error("download exceeds reviewed size bound");
+  if (existsSync2(destination))
+    throw new Error("download destination already exists");
+  await Bun.write(destination, response);
+  chmodSync2(destination, 384);
+  if (statSync(destination).size > maximumBytes) {
+    rmSync(destination, { force: true });
+    throw new Error("download exceeds reviewed size bound");
+  }
+  const digest = createHash("sha256");
+  for await (const chunk of createReadStream(destination))
+    digest.update(chunk);
+  if (digest.digest("hex") !== sha2562) {
+    rmSync(destination, { force: true });
     throw new Error("download checksum mismatch");
-  writeFileSync(destination, bytes, { mode: 384, flag: "wx" });
+  }
 };
 var successful = (result, pattern) => result.exitCode === 0 && (!pattern || pattern.test(result.output));
 var aptInstall = async (name) => {
@@ -5075,6 +5143,106 @@ var aptInstall = async (name) => {
   const update = await run(["/usr/bin/apt-get", "update", "-qq"], environment);
   return update.exitCode === 0 ? run(["/usr/bin/apt-get", "install", "-y", name], environment) : update;
 };
+var aptInstallMany = async (names) => {
+  const environment = { DEBIAN_FRONTEND: "noninteractive" };
+  const update = await run(["/usr/bin/apt-get", "update", "-qq"], environment);
+  return update.exitCode === 0 ? run(["/usr/bin/apt-get", "install", "-y", ...names], environment) : update;
+};
+var writeOwnedPolicy = (pathValue, content, mode = 420) => {
+  if (existsSync2(pathValue)) {
+    if (readFileSync(pathValue, "utf8") !== content)
+      throw new Error(`refusing to overwrite non-ForgeZero policy at ${pathValue}`);
+    return;
+  }
+  mkdirSync(dirname(pathValue), { recursive: true, mode: 493 });
+  writeFileSync(pathValue, content, { mode, flag: "wx" });
+};
+var installContainerdRuntime = async (directory, osVersion) => {
+  const installed = await aptInstallMany(["containerd", "runc", "containernetworking-plugins"]);
+  if (installed.exitCode !== 0)
+    return installed;
+  const nerdctl = join(directory, "nerdctl.tar.gz");
+  await download(`https://github.com/containerd/nerdctl/releases/download/v${NERDCTL_VERSION}/nerdctl-${NERDCTL_VERSION}-linux-amd64.tar.gz`, nerdctl, NERDCTL_SHA256);
+  const nerdctlExtract = await run(["/usr/bin/tar", "-xzf", nerdctl, "-C", "/usr/local/bin", "nerdctl"]);
+  if (nerdctlExtract.exitCode !== 0)
+    return nerdctlExtract;
+  chmodSync2("/usr/local/bin/nerdctl", 493);
+  const buildkit = join(directory, "buildkit.tar.gz");
+  await download(`https://github.com/moby/buildkit/releases/download/v${BUILDKIT_VERSION}/buildkit-v${BUILDKIT_VERSION}.linux-amd64.tar.gz`, buildkit, BUILDKIT_SHA256);
+  const unpacked = join(directory, "buildkit");
+  mkdirSync(unpacked, { mode: 448 });
+  const buildkitExtract = await run(["/usr/bin/tar", "-xzf", buildkit, "-C", unpacked]);
+  if (buildkitExtract.exitCode !== 0)
+    return buildkitExtract;
+  for (const binary of ["buildctl", "buildkitd"]) {
+    copyFileSync(join(unpacked, "bin", binary), `/usr/local/bin/${binary}`);
+    chmodSync2(`/usr/local/bin/${binary}`, 493);
+  }
+  mkdirSync("/etc/containerd", { recursive: true, mode: 493 });
+  const expected = CONTAINERD_CONFIG(false);
+  const kataExpected = CONTAINERD_CONFIG(true);
+  if (existsSync2(CONTAINERD_CONFIG_PATH) && ![expected, kataExpected].includes(readFileSync(CONTAINERD_CONFIG_PATH, "utf8"))) {
+    return { exitCode: 2, output: "refusing to overwrite an existing containerd configuration that differs from the reviewed ForgeZero policy" };
+  }
+  if (!existsSync2(CONTAINERD_CONFIG_PATH))
+    writeFileSync(CONTAINERD_CONFIG_PATH, expected, { mode: 420, flag: "wx" });
+  writeOwnedPolicy("/etc/systemd/system/forgezero-buildkit.service", BUILDKIT_UNIT);
+  mkdirSync("/var/lib/forgezero/containerd", { recursive: true, mode: 448 });
+  mkdirSync("/var/lib/forgezero/buildkit", { recursive: true, mode: 448 });
+  const reload = await run(["/usr/bin/systemctl", "daemon-reload"]);
+  if (reload.exitCode !== 0)
+    return reload;
+  const enabled = await run(["/usr/bin/systemctl", "enable", "--now", "containerd.service", "forgezero-buildkit.service"]);
+  return enabled.exitCode === 0 ? { exitCode: 0, output: `containerd ${osVersion} with nerdctl ${NERDCTL_VERSION} and BuildKit ${BUILDKIT_VERSION}` } : enabled;
+};
+var installKataRuntime = async (directory) => {
+  for (const pathValue of ["/dev/kvm", "/dev/sev"])
+    if (!existsSync2(pathValue))
+      return { exitCode: 2, output: `${pathValue} is required for Kata SEV-SNP` };
+  for (const parameter of ["/sys/module/kvm_amd/parameters/sev", "/sys/module/kvm_amd/parameters/sev_snp"]) {
+    if (!existsSync2(parameter) || !/^(1|Y)$/i.test(readFileSync(parameter, "utf8").trim()))
+      return { exitCode: 2, output: `${parameter} does not enable SEV-SNP` };
+  }
+  const dependencies = await aptInstallMany(["zstd"]);
+  if (dependencies.exitCode !== 0)
+    return dependencies;
+  const archive = join(directory, "kata.tar.zst");
+  await download(`https://github.com/kata-containers/kata-containers/releases/download/${KATA_CONTAINERS_VERSION}/kata-static-${KATA_CONTAINERS_VERSION}-amd64.tar.zst`, archive, KATA_SHA256, 2200000000);
+  const tar = join(directory, "kata.tar");
+  const expanded = await run(["/usr/bin/unzstd", "--quiet", archive, "--output", tar]);
+  if (expanded.exitCode !== 0)
+    return expanded;
+  const extracted = await run(["/usr/bin/tar", "-xf", tar, "-C", "/"]);
+  if (extracted.exitCode !== 0)
+    return extracted;
+  if (!existsSync2("/opt/kata/bin/containerd-shim-kata-v2") || !existsSync2(KATA_SNP_CONFIG_PATH)) {
+    return { exitCode: 2, output: "Kata archive does not contain the reviewed QEMU SNP runtime and configuration" };
+  }
+  const snpConfig = readFileSync(KATA_SNP_CONFIG_PATH, "utf8");
+  if (!/^\s*confidential_guest\s*=\s*true\s*$/m.test(snpConfig) || !/^\s*sev_snp_guest\s*=\s*true\s*$/m.test(snpConfig)) {
+    return { exitCode: 2, output: "Kata QEMU configuration does not enable confidential SEV-SNP guests" };
+  }
+  mkdirSync("/etc/kata-containers", { recursive: true, mode: 493 });
+  if (existsSync2(KATA_ACTIVE_CONFIG_PATH) && readFileSync(KATA_ACTIVE_CONFIG_PATH, "utf8") !== snpConfig) {
+    return { exitCode: 2, output: "refusing to overwrite a non-ForgeZero Kata runtime configuration" };
+  }
+  if (!existsSync2(KATA_ACTIVE_CONFIG_PATH))
+    copyFileSync(KATA_SNP_CONFIG_PATH, KATA_ACTIVE_CONFIG_PATH);
+  chmodSync2(KATA_ACTIVE_CONFIG_PATH, 420);
+  try {
+    unlinkSync2("/usr/local/bin/containerd-shim-kata-v2");
+  } catch {}
+  symlinkSync("/opt/kata/bin/containerd-shim-kata-v2", "/usr/local/bin/containerd-shim-kata-v2");
+  const base = CONTAINERD_CONFIG(false);
+  const kata = CONTAINERD_CONFIG(true);
+  if (!existsSync2(CONTAINERD_CONFIG_PATH) || ![base, kata].includes(readFileSync(CONTAINERD_CONFIG_PATH, "utf8"))) {
+    return { exitCode: 2, output: "containerd must use the reviewed ForgeZero policy before Kata is installed" };
+  }
+  if (readFileSync(CONTAINERD_CONFIG_PATH, "utf8") !== kata)
+    writeFileSync(CONTAINERD_CONFIG_PATH, kata, { mode: 420 });
+  const restarted = await run(["/usr/bin/systemctl", "restart", "containerd.service"]);
+  return restarted.exitCode === 0 ? { exitCode: 0, output: `Kata Containers ${KATA_CONTAINERS_VERSION} QEMU SNP` } : restarted;
+};
 async function executeSoftwareOperation(operation) {
   const { software, version } = operation;
   if (![...UBUNTU_2604_X64, ...UBUNTU_2404_X64].some(({ requirement }) => requirement.id === software && requirement.version === version)) {
@@ -5092,6 +5260,26 @@ async function executeSoftwareOperation(operation) {
       const active = await run(["/usr/bin/systemctl", "is-active", "--quiet", "docker.service"]);
       return active.exitCode === 0 ? { exitCode: 0, output: binary.output } : active;
     }
+    if (software === "containerd") {
+      const [containerd, nerdctl, buildkit, active, builder] = await Promise.all([
+        run(["/usr/bin/containerd", "--version"]),
+        run(["/usr/local/bin/nerdctl", "--version"]),
+        run(["/usr/local/bin/buildkitd", "--version"]),
+        run(["/usr/bin/systemctl", "is-active", "--quiet", "containerd.service"]),
+        run(["/usr/bin/systemctl", "is-active", "--quiet", "forgezero-buildkit.service"])
+      ]);
+      const policy = existsSync2(CONTAINERD_CONFIG_PATH) ? readFileSync(CONTAINERD_CONFIG_PATH, "utf8") : "";
+      const validPolicy = policy === CONTAINERD_CONFIG(false) || policy === CONTAINERD_CONFIG(true);
+      return successful(containerd, /containerd/) && successful(nerdctl, new RegExp(NERDCTL_VERSION.replaceAll(".", "\\."))) && successful(buildkit, new RegExp(BUILDKIT_VERSION.replaceAll(".", "\\."))) && active.exitCode === 0 && builder.exitCode === 0 && validPolicy ? { exitCode: 0, output: `${containerd.output}${nerdctl.output}${buildkit.output}` } : { exitCode: 1, output: "containerd, nerdctl, BuildKit, or ForgeZero storage/runtime policy is unavailable" };
+    }
+    if (software === "kata-containers") {
+      const shim = await run(["/opt/kata/bin/containerd-shim-kata-v2", "--version"]);
+      const policy = existsSync2(CONTAINERD_CONFIG_PATH) ? readFileSync(CONTAINERD_CONFIG_PATH, "utf8") : "";
+      const activeConfig = existsSync2(KATA_ACTIVE_CONFIG_PATH) ? readFileSync(KATA_ACTIVE_CONFIG_PATH, "utf8") : "";
+      const host = ["/dev/kvm", "/dev/sev", KATA_SNP_CONFIG_PATH, KATA_ACTIVE_CONFIG_PATH].every(existsSync2) && ["/sys/module/kvm_amd/parameters/sev", "/sys/module/kvm_amd/parameters/sev_snp"].every((parameter) => existsSync2(parameter) && /^(1|Y)$/i.test(readFileSync(parameter, "utf8").trim()));
+      const active = await run(["/usr/bin/systemctl", "is-active", "--quiet", "containerd.service"]);
+      return successful(shim, /kata.*4\.0\.0/i) && policy === CONTAINERD_CONFIG(true) && activeConfig === (existsSync2(KATA_SNP_CONFIG_PATH) ? readFileSync(KATA_SNP_CONFIG_PATH, "utf8") : "") && host && active.exitCode === 0 ? { exitCode: 0, output: shim.output } : { exitCode: 1, output: "Kata QEMU SNP runtime, host capability, or containerd policy is unavailable" };
+    }
     if (software === "nginx") {
       const binary = await run(["/usr/sbin/nginx", "-v"]);
       return binary.exitCode === 0 ? run(["/usr/bin/systemctl", "is-active", "--quiet", "nginx.service"]) : binary;
@@ -5143,6 +5331,17 @@ async function executeSoftwareOperation(operation) {
   }
   const directory = mkdtempSync(join(tmpdir(), "forgezero-software-"));
   try {
+    if (software === "containerd")
+      return installContainerdRuntime(directory, version === "ubuntu-24.04" ? "24.04" : "26.04");
+    if (software === "kata-containers") {
+      const containerd = await executeSoftwareOperation({ kind: "check", software: "containerd", version: "ubuntu-26.04" });
+      if (containerd.exitCode !== 0) {
+        const installed2 = await installContainerdRuntime(directory, "26.04");
+        if (installed2.exitCode !== 0)
+          return installed2;
+      }
+      return installKataRuntime(directory);
+    }
     if (software === "cloudflare-warp") {
       const key = join(directory, "cloudflare-warp-key.gpg");
       await download("https://pkg.cloudflareclient.com/pubkey.gpg", key, "0f37fc298c98e88ee3c0ee68c95b69f1dba9eb477abe3167e13982105911264d");
@@ -5224,7 +5423,7 @@ function validateSoftwareRequirements(value, _options = {}) {
     if (Object.keys(row).some((key) => key !== "id" && key !== "version")) {
       throw new Error("software requirement contains an unknown field");
     }
-    if (!["bun", "docker", "nginx", "arangodb", "cloudflared", "cloudflare-warp", "ufw", "openssh-client", "git"].includes(String(row.id)) || typeof row.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9.-]{0,31}$/.test(row.version)) {
+    if (!["bun", "docker", "containerd", "kata-containers", "nginx", "arangodb", "cloudflared", "cloudflare-warp", "ufw", "openssh-client", "git"].includes(String(row.id)) || typeof row.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9.-]{0,31}$/.test(row.version)) {
       throw new Error("software requirement coordinate is invalid");
     }
     const requirement = { id: row.id, version: row.version };
@@ -5998,6 +6197,13 @@ function validateBuiltInAction(definition, context, where) {
       throw new Error(`${where}.with.requirements must name existing requirements`);
     return;
   }
+  if (definition.uses === "forgezero.network/ensure@1") {
+    exact(withValue, ["target"], `${where}.with`);
+    if (typeof withValue.target !== "string" || !Object.values(context.components).some((entry) => entry.target === withValue.target)) {
+      throw new Error(`${where}.with.target must name a target used by a component`);
+    }
+    return;
+  }
   if (definition.uses === "forgezero.exec/argv@1") {
     const allowed = ["component", "argv", "credentials"];
     const unknown = Object.keys(withValue).filter((key) => !allowed.includes(key));
@@ -6053,6 +6259,8 @@ function validateBuiltInProvider(requirement2, where) {
   const expected = {
     "forgezero.bun": { capability: "runtime.javascript", versions: ["1.3.14"], keys: ["installScope"] },
     "forgezero.docker": { capability: "runtime.container", versions: ["ubuntu-24.04", "ubuntu-26.04"], keys: ["installScope", "storageDriver", "dataRoot", "liveRestore", "logDriver", "defaultNetwork", "rootless"] },
+    "forgezero.containerd": { capability: "runtime.container", versions: ["ubuntu-24.04", "ubuntu-26.04"], keys: ["installScope", "runtimeClass", "namespace", "snapshotter"] },
+    "forgezero.kata": { capability: "runtime.container", versions: ["4.0.0"], keys: ["installScope", "runtimeClass", "namespace", "hypervisor", "confidentialGuest"] },
     "forgezero.nginx": { capability: "proxy.http", versions: ["ubuntu-24.04", "ubuntu-26.04"], keys: ["installScope", "websocket", "maximumBodyMiB", "workerProcesses", "workerConnections"] },
     "forgezero.arangodb": { capability: "database.arangodb", versions: ["3.11.14"], keys: ["installScope", "runtime", "dataPath", "bind"] },
     "forgezero.cloudflared": { capability: "network.public-tunnel", versions: ["2026.7.3"], keys: ["installScope", "mode"] },
@@ -6073,6 +6281,10 @@ function validateBuiltInProvider(requirement2, where) {
     if (row2.storageDriver !== "overlay2" || row2.dataRoot !== "/var/lib/docker" || row2.liveRestore !== true || row2.logDriver !== "local" || row2.defaultNetwork !== "bridge" || row2.rootless !== false)
       throw new Error(`${where} Docker config is unsupported by the fixed host strategy`);
   }
+  if (requirement2.provider === "forgezero.containerd" && (row2.runtimeClass !== "runc" || row2.namespace !== "forgezero" || row2.snapshotter !== "overlayfs"))
+    throw new Error(`${where} containerd config is unsupported by the fixed host strategy`);
+  if (requirement2.provider === "forgezero.kata" && (row2.runtimeClass !== "kata-qemu-snp" || row2.namespace !== "forgezero" || row2.hypervisor !== "qemu" || row2.confidentialGuest !== "sev-snp"))
+    throw new Error(`${where} Kata config is unsupported by the fixed host strategy`);
   if (requirement2.provider === "forgezero.nginx" && (typeof row2.websocket !== "boolean" || !Number.isInteger(row2.maximumBodyMiB) || Number(row2.maximumBodyMiB) < 1 || Number(row2.maximumBodyMiB) > 1024 || !(row2.workerProcesses === "auto" || Number.isInteger(row2.workerProcesses)) || !Number.isInteger(row2.workerConnections)))
     throw new Error(`${where} Nginx config is invalid`);
   if (requirement2.provider === "forgezero.arangodb" && (row2.runtime !== "native" || !absolute(row2.dataPath) || row2.bind !== "private"))
@@ -6150,7 +6362,7 @@ function reference(value, where) {
   const row2 = object(value, where);
   exact3(row2, ["$ref"], where);
   const coordinate = boundedString(row2.$ref, `${where}.$ref`, 256);
-  if (!/^(inputs\.[a-z][A-Za-z0-9-]{0,62}|steps\.[a-z][A-Za-z0-9-]{0,62}\.(status|outputs\.[a-z][A-Za-z0-9-]{0,62})|components\.[a-z][A-Za-z0-9-]{0,62}\.[a-z][A-Za-z0-9-]{0,62}|targets\.[a-z][A-Za-z0-9-]{0,62}\.[a-z][A-Za-z0-9-]{0,62}|deployment\.[a-z][A-Za-z0-9-]{0,62})$/.test(coordinate)) {
+  if (!/^(inputs\.[a-z][A-Za-z0-9-]{0,62}|steps\.[a-z][A-Za-z0-9-]{0,62}\.(status|outputs\.[a-z][A-Za-z0-9-]{0,62})|components\.[a-z][A-Za-z0-9-]{0,62}\.[a-z][A-Za-z0-9-]{0,62}|targets\.[a-z][A-Za-z0-9-]{0,62}\.[a-z][A-Za-z0-9-]{0,62}|deployment\.[a-z][A-Za-z0-9-]{0,62}|execution\.(targetName|slot|releaseExecutor|runtime|cpuCores|memoryMiB|storageGiB))$/.test(coordinate)) {
     fail(where, "contains an unsupported reference.");
   }
   return { $ref: coordinate };
@@ -6390,10 +6602,9 @@ function validateNetwork(value, where) {
       named(container.network, `${where}.container.network`);
   }
 }
-function validateComponent(value, where, targetNames, requirements) {
+function validateComponent(value, where, targets, requirements) {
   const row2 = object(value, where);
-  if (!targetNames.has(String(row2.target)))
-    fail(`${where}.target`, "must name an existing target.");
+  const selectedTarget = targets.get(String(row2.target)) ?? fail(`${where}.target`, "must name an existing target.");
   if (row2.kind === "application") {
     exact3(row2, ["kind", "target", "runtime", "service", "resources", "storage", "network", "rollout"], where);
     const runtime = object(row2.runtime, `${where}.runtime`);
@@ -6404,7 +6615,9 @@ function validateComponent(value, where, targetNames, requirements) {
       exact3(runtime, ["kind", "provider", "requirement", "argv"], `${where}.runtime`);
       validateArgv(runtime.argv, `${where}.runtime.argv`);
     } else if (runtime.kind === "container") {
-      exact3(runtime, ["kind", "provider", "requirement", "image", "entrypoint", "security"], `${where}.runtime`);
+      exact3(runtime, ["kind", "provider", "requirement", "runtimeClass", "image", "entrypoint", "security"], `${where}.runtime`);
+      if (runtime.runtimeClass !== undefined && !["runc", "kata-qemu-snp"].includes(String(runtime.runtimeClass)))
+        fail(`${where}.runtime.runtimeClass`, "is unsupported.");
       const image = object(runtime.image, `${where}.runtime.image`);
       exact3(image, ["source"], `${where}.runtime.image`);
       const source = object(image.source, `${where}.runtime.image.source`);
@@ -6438,6 +6651,23 @@ function validateComponent(value, where, targetNames, requirements) {
       fail(`${where}.runtime.requirement`, "must provide runtime.container.");
     if (runtimeRequirement && runtime.kind === "native" && !runtimeRequirement.capability.startsWith("runtime."))
       fail(`${where}.runtime.requirement`, "must provide a runtime capability.");
+    const execution = selectedTarget.allocation.execution;
+    if (execution === "native" && runtime.kind !== "native")
+      fail(`${where}.runtime.kind`, "must be native for the selected target.");
+    if (execution !== "native" && runtime.kind !== "container")
+      fail(`${where}.runtime.kind`, "must be container for the selected target.");
+    if (runtime.kind === "container" && execution === "oci-runc") {
+      if (!["forgezero.containerd", "forgezero.docker"].includes(String(runtime.provider)))
+        fail(`${where}.runtime.provider`, "must be forgezero.containerd for an OCI runc target.");
+      if (runtime.runtimeClass !== undefined && runtime.runtimeClass !== "runc")
+        fail(`${where}.runtime.runtimeClass`, "must be runc for the selected target.");
+    }
+    if (runtime.kind === "container" && execution === "oci-kata-qemu-snp") {
+      if (runtime.provider !== "forgezero.kata")
+        fail(`${where}.runtime.provider`, "must be forgezero.kata for a Kata QEMU SNP target.");
+      if (runtime.runtimeClass !== "kata-qemu-snp")
+        fail(`${where}.runtime.runtimeClass`, "must be kata-qemu-snp for the selected target.");
+    }
     const service = object(row2.service, `${where}.service`);
     exact3(service, ["protocol", "port", "health", "websocket", "maximumConnections"], `${where}.service`);
     if (service.protocol !== "http")
@@ -6469,6 +6699,18 @@ function validateComponent(value, where, targetNames, requirements) {
       const network = object(row2.network, `${where}.network`);
       if (network.container === undefined)
         fail(`${where}.network.container`, "must select bridge or reviewed host networking.");
+      if (selectedTarget.allocation.sharing === "shared") {
+        if (object(runtime.security, `${where}.runtime.security`).root !== "read-only")
+          fail(`${where}.runtime.security.root`, "must be read-only on a shared compute.");
+        if (network.container.mode !== "bridge")
+          fail(`${where}.network.container.mode`, "must be bridge on a shared compute.");
+        if (Array.isArray(row2.storage) && row2.storage.some((mount) => mount.class !== "ephemeral")) {
+          fail(`${where}.storage`, "may contain only size-bounded tmpfs mounts on a shared compute.");
+        }
+      }
+    }
+    if (runtime.kind === "native" && selectedTarget.allocation.sharing !== "exclusive") {
+      fail(`${where}.target`, "native applications require an exclusive compute.");
     }
     if (row2.storage !== undefined) {
       if (!Array.isArray(row2.storage) || row2.storage.length > 32)
@@ -6505,6 +6747,8 @@ function validateComponent(value, where, targetNames, requirements) {
       fail(`${where}.runtime.mode`, "must match the provider runtime mode.");
     if (runtime.mode !== "native")
       fail(`${where}.runtime.mode`, "must be native in deployment plan v1.");
+    if (selectedTarget.allocation.execution !== "native")
+      fail(`${where}.target`, "must select a native execution target for database components.");
     const topology = object(row2.topology, `${where}.topology`);
     if (topology.mode === "standalone")
       exact3(topology, ["mode"], `${where}.topology`);
@@ -6701,15 +6945,20 @@ function compileDeployment(sourceValue) {
   if (targetEntries.length < 1 || targetEntries.length > 64)
     fail("deployment.spec.targets", "must contain 1 to 64 targets.");
   const targetNames = new Set(targetEntries.map(([targetName]) => named(targetName, "deployment.spec.targets key")));
+  const targetDefinitions = new Map;
   for (const [targetName, value] of targetEntries) {
     const target = object(value, `deployment.spec.targets.${targetName}`);
-    exact3(target, ["kind", "selector", "cardinality", "placement"], `deployment.spec.targets.${targetName}`);
+    exact3(target, ["kind", "selector", "cardinality", "allocation", "provisioning", "connectivity", "placement"], `deployment.spec.targets.${targetName}`);
     if (target.kind !== "compute")
       fail(`deployment.spec.targets.${targetName}.kind`, "must be compute.");
     const selector = object(target.selector, `deployment.spec.targets.${targetName}.selector`);
-    exact3(selector, ["profiles", "confidentialCompute", "labels"], `deployment.spec.targets.${targetName}.selector`);
+    exact3(selector, ["profiles", "operatingSystem", "confidentialCompute", "labels"], `deployment.spec.targets.${targetName}.selector`);
     if (!Array.isArray(selector.profiles) || selector.profiles.length < 1 || selector.profiles.length > 32 || selector.profiles.some((profile) => typeof profile !== "string" || !NAME2.test(profile)) || new Set(selector.profiles).size !== selector.profiles.length)
       fail(`deployment.spec.targets.${targetName}.selector.profiles`, "is invalid.");
+    const operatingSystem = object(selector.operatingSystem, `deployment.spec.targets.${targetName}.selector.operatingSystem`);
+    exact3(operatingSystem, ["id", "version", "architecture"], `deployment.spec.targets.${targetName}.selector.operatingSystem`);
+    if (operatingSystem.id !== "ubuntu" || !["24.04", "26.04"].includes(String(operatingSystem.version)) || operatingSystem.architecture !== "x64")
+      fail(`deployment.spec.targets.${targetName}.selector.operatingSystem`, "is unsupported.");
     if (selector.confidentialCompute !== undefined && !["required", "preferred", "disabled"].includes(String(selector.confidentialCompute)))
       fail(`deployment.spec.targets.${targetName}.selector.confidentialCompute`, "is unsupported.");
     if (selector.labels !== undefined)
@@ -6722,8 +6971,108 @@ function compileDeployment(sourceValue) {
       integer(cardinality.desired, `deployment.spec.targets.${targetName}.cardinality.desired`, minimum, maximum);
     else
       reference(cardinality.desired, `deployment.spec.targets.${targetName}.cardinality.desired`);
+    const allocation = object(target.allocation, `deployment.spec.targets.${targetName}.allocation`);
+    exact3(allocation, ["execution", "sharing", "resources", "existing"], `deployment.spec.targets.${targetName}.allocation`);
+    if (!["native", "oci-runc", "oci-kata-qemu-snp"].includes(String(allocation.execution)))
+      fail(`deployment.spec.targets.${targetName}.allocation.execution`, "is unsupported.");
+    if (!["exclusive", "shared"].includes(String(allocation.sharing)))
+      fail(`deployment.spec.targets.${targetName}.allocation.sharing`, "is unsupported.");
+    if (!["prefer", "require"].includes(String(allocation.existing)))
+      fail(`deployment.spec.targets.${targetName}.allocation.existing`, "is unsupported.");
+    const capacity = object(allocation.resources, `deployment.spec.targets.${targetName}.allocation.resources`);
+    exact3(capacity, ["cpuCores", "memoryMiB", "storageGiB"], `deployment.spec.targets.${targetName}.allocation.resources`);
+    const capacityValue = (value2, where, minimumValue, maximumValue) => {
+      if (typeof value2 === "number")
+        integer(value2, where, minimumValue, maximumValue);
+      else
+        reference(value2, where);
+    };
+    capacityValue(capacity.cpuCores, `deployment.spec.targets.${targetName}.allocation.resources.cpuCores`, 1, 1024);
+    capacityValue(capacity.memoryMiB, `deployment.spec.targets.${targetName}.allocation.resources.memoryMiB`, 128, 4194304);
+    capacityValue(capacity.storageGiB, `deployment.spec.targets.${targetName}.allocation.resources.storageGiB`, 1, 1048576);
+    if (allocation.execution === "oci-kata-qemu-snp" && selector.confidentialCompute !== "required")
+      fail(`deployment.spec.targets.${targetName}.selector.confidentialCompute`, "must be required for Kata QEMU SNP.");
+    if ((allocation.execution === "oci-kata-qemu-snp" || selector.confidentialCompute === "required") && operatingSystem.version !== "26.04")
+      fail(`deployment.spec.targets.${targetName}.selector.operatingSystem.version`, "must be Ubuntu 26.04 for SEV-SNP.");
+    if (allocation.execution !== "oci-kata-qemu-snp" && selector.confidentialCompute === "required" && allocation.execution !== "native")
+      fail(`deployment.spec.targets.${targetName}.allocation.execution`, "cannot satisfy required confidential compute.");
+    if (target.provisioning !== undefined) {
+      const provisioning = object(target.provisioning, `deployment.spec.targets.${targetName}.provisioning`);
+      exact3(provisioning, ["planKey", "regionKey", "imageKey", "environmentKey", "ownership", "metalHostname", "maxMonthlySpendMinor"], `deployment.spec.targets.${targetName}.provisioning`);
+      for (const key of ["planKey", "regionKey", "imageKey", "environmentKey"])
+        named(provisioning[key], `deployment.spec.targets.${targetName}.provisioning.${key}`);
+      if (!["platform", "tenant-metal"].includes(String(provisioning.ownership)) || provisioning.ownership === "tenant-metal" !== Boolean(provisioning.metalHostname))
+        fail(`deployment.spec.targets.${targetName}.provisioning.ownership`, "must bind platform capacity or one tenant metal hostname.");
+      if (provisioning.metalHostname !== undefined && !/^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/.test(String(provisioning.metalHostname)))
+        fail(`deployment.spec.targets.${targetName}.provisioning.metalHostname`, "is invalid.");
+      if (typeof provisioning.maxMonthlySpendMinor !== "string" || !/^\d{1,18}$/.test(provisioning.maxMonthlySpendMinor))
+        fail(`deployment.spec.targets.${targetName}.provisioning.maxMonthlySpendMinor`, "must be a bounded decimal minor-unit amount.");
+    }
+    if (allocation.existing === "prefer" && target.provisioning === undefined)
+      fail(`deployment.spec.targets.${targetName}.provisioning`, "is required when placement may provision after reuse.");
+    if (allocation.existing === "require" && target.provisioning !== undefined)
+      fail(`deployment.spec.targets.${targetName}.provisioning`, "must be omitted for reuse-only placement.");
+    if (target.connectivity !== undefined) {
+      const connectivity = object(target.connectivity, `deployment.spec.targets.${targetName}.connectivity`);
+      exact3(connectivity, ["private", "public"], `deployment.spec.targets.${targetName}.connectivity`);
+      const declaredPrivate = connectivity.private === undefined ? undefined : object(connectivity.private, `deployment.spec.targets.${targetName}.connectivity.private`);
+      if (declaredPrivate?.mode === "cloudflare-warp" && allocation.sharing !== "exclusive")
+        fail(`deployment.spec.targets.${targetName}.allocation.sharing`, "must be exclusive for a Cloudflare WARP connector.");
+      if (connectivity.private !== undefined) {
+        const privateNetwork = declaredPrivate;
+        if (privateNetwork.mode === "cloudflare-warp") {
+          exact3(privateNetwork, ["mode", "credential", "network"], `deployment.spec.targets.${targetName}.connectivity.private`);
+          if (!credentials[named(privateNetwork.credential, `deployment.spec.targets.${targetName}.connectivity.private.credential`)])
+            fail(`deployment.spec.targets.${targetName}.connectivity.private.credential`, "must name a declared credential.");
+          if (typeof privateNetwork.network === "string")
+            named(privateNetwork.network, `deployment.spec.targets.${targetName}.connectivity.private.network`);
+          else
+            reference(privateNetwork.network, `deployment.spec.targets.${targetName}.connectivity.private.network`);
+        } else {
+          exact3(privateNetwork, ["mode"], `deployment.spec.targets.${targetName}.connectivity.private`);
+          if (!["disabled", "private-lan"].includes(String(privateNetwork.mode)))
+            fail(`deployment.spec.targets.${targetName}.connectivity.private.mode`, "is unsupported.");
+        }
+      }
+      if (connectivity.public !== undefined) {
+        const publicNetwork = object(connectivity.public, `deployment.spec.targets.${targetName}.connectivity.public`);
+        if (publicNetwork.mode === "cloudflare-tunnel") {
+          exact3(publicNetwork, ["mode", "credential", "zone", "hostname"], `deployment.spec.targets.${targetName}.connectivity.public`);
+          if (!credentials[named(publicNetwork.credential, `deployment.spec.targets.${targetName}.connectivity.public.credential`)])
+            fail(`deployment.spec.targets.${targetName}.connectivity.public.credential`, "must name a declared credential.");
+          if (typeof publicNetwork.zone === "string") {
+            if (!/^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(publicNetwork.zone))
+              fail(`deployment.spec.targets.${targetName}.connectivity.public.zone`, "is invalid.");
+          } else
+            reference(publicNetwork.zone, `deployment.spec.targets.${targetName}.connectivity.public.zone`);
+          const hostname = object(publicNetwork.hostname, `deployment.spec.targets.${targetName}.connectivity.public.hostname`);
+          const value2 = (coordinate, where, pattern) => {
+            if (typeof coordinate === "string") {
+              if (!pattern.test(coordinate))
+                fail(where, "is invalid.");
+            } else
+              reference(coordinate, where);
+          };
+          if (hostname.mode === "static") {
+            exact3(hostname, ["mode", "label"], `deployment.spec.targets.${targetName}.connectivity.public.hostname`);
+            value2(hostname.label, `deployment.spec.targets.${targetName}.connectivity.public.hostname.label`, /^[a-z0-9](?:[a-z0-9-]{0,48}[a-z0-9])?$/);
+          } else if (hostname.mode === "indexed") {
+            exact3(hostname, ["mode", "prefix", "startAt"], `deployment.spec.targets.${targetName}.connectivity.public.hostname`);
+            value2(hostname.prefix, `deployment.spec.targets.${targetName}.connectivity.public.hostname.prefix`, /^[a-z0-9](?:[a-z0-9-]{0,48}[a-z0-9])?$/);
+            if (hostname.startAt !== undefined)
+              integer(hostname.startAt, `deployment.spec.targets.${targetName}.connectivity.public.hostname.startAt`, 0, 1e6);
+          } else
+            fail(`deployment.spec.targets.${targetName}.connectivity.public.hostname.mode`, "is unsupported.");
+        } else {
+          exact3(publicNetwork, ["mode"], `deployment.spec.targets.${targetName}.connectivity.public`);
+          if (publicNetwork.mode !== "disabled")
+            fail(`deployment.spec.targets.${targetName}.connectivity.public.mode`, "is unsupported.");
+        }
+      }
+    }
     if (target.placement !== undefined)
       jsonValue(target.placement, `deployment.spec.targets.${targetName}.placement`);
+    targetDefinitions.set(targetName, target);
   }
   const requirements = object(spec.requirements ?? {}, "deployment.spec.requirements");
   if (Object.keys(requirements).length > 64)
@@ -6737,13 +7086,34 @@ function compileDeployment(sourceValue) {
     const key = `${requirementValue.provider}@${requirementValue.contract}:${requirementValue.capability}`;
     requiredProviders.set(key, { provider: requirementValue.provider, contract: requirementValue.contract, capability: requirementValue.capability });
   }
+  for (const [targetName, target] of targetDefinitions) {
+    if (target.connectivity?.public?.mode === "cloudflare-tunnel" && ![...requirementDefinitions.values()].some(({ capability }) => capability === "network.public-tunnel")) {
+      fail(`deployment.spec.targets.${targetName}.connectivity.public`, "requires one network.public-tunnel provider requirement.");
+    }
+    if (target.connectivity?.private?.mode === "cloudflare-warp" && ![...requirementDefinitions.values()].some(({ capability }) => capability === "network.private")) {
+      fail(`deployment.spec.targets.${targetName}.connectivity.private`, "requires one network.private provider requirement.");
+    }
+  }
   const components = object(spec.components, "deployment.spec.components");
   const componentEntries = Object.entries(components);
   if (componentEntries.length < 1 || componentEntries.length > 128)
     fail("deployment.spec.components", "must contain 1 to 128 components.");
   for (const [componentName, value] of componentEntries) {
     named(componentName, "deployment.spec.components key");
-    validateComponent(value, `deployment.spec.components.${componentName}`, targetNames, requirementDefinitions);
+    validateComponent(value, `deployment.spec.components.${componentName}`, targetDefinitions, requirementDefinitions);
+  }
+  for (const [targetName, target] of targetDefinitions) {
+    if (target.connectivity?.public?.mode !== "cloudflare-tunnel")
+      continue;
+    const publicApplications = componentEntries.filter(([, component2]) => {
+      const candidate = component2;
+      return candidate.kind === "application" && candidate.target === targetName && candidate.network?.public?.mode === "cloudflare-tunnel";
+    });
+    if (publicApplications.length !== 1)
+      fail(`deployment.spec.targets.${targetName}.connectivity.public`, "requires exactly one application on the target with network.public cloudflare-tunnel.");
+    const application = publicApplications[0][1];
+    if (application.kind !== "application" || !application.network?.ingress?.stablePort)
+      fail(`deployment.spec.components.${publicApplications[0][0]}.network.ingress`, "requires one stablePort for Tunnel ingress.");
   }
   const actionContext = {
     components,
@@ -6785,6 +7155,14 @@ function compileDeployment(sourceValue) {
     });
     plannedWorkflows.push({ id: workflowName, ...workflowValue.concurrency ? { concurrency: workflowValue.concurrency } : {}, stages: plannedStages });
   }
+  const deployWorkflow = plannedWorkflows.find(({ id: id2 }) => id2 === "deploy");
+  for (const [targetName, target] of targetDefinitions) {
+    if (!target.connectivity || target.connectivity.public?.mode !== "cloudflare-tunnel" && target.connectivity.private?.mode !== "cloudflare-warp")
+      continue;
+    const ensures = deployWorkflow?.stages.flatMap(({ steps }) => steps).filter((step2) => step2.uses === "forgezero.network/ensure@1" && step2.with.target === targetName && (step2.scope.kind === "each-target" || step2.scope.kind === "target-batches") && step2.scope.target === targetName) ?? [];
+    if (ensures.length !== 1)
+      fail(`deployment.spec.workflows.deploy`, `must contain exactly one network.ensure step scoped to connected target ${targetName}.`);
+  }
   const typedSource = source;
   return {
     format: DEPLOY_PLAN_FORMAT,
@@ -6871,6 +7249,143 @@ function parseDeploymentPlan(value) {
   return { ...compiled, sourceDigest: row2.sourceDigest };
 }
 
+// src/deployment-targets.ts
+class DeploymentInputError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeploymentInputError";
+  }
+}
+var HOSTNAME = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/;
+function inputValue(name, definition, supplied) {
+  let value = supplied ?? definition.default;
+  if (value === undefined) {
+    if (definition.required)
+      throw new DeploymentInputError(`deployment input ${name} is required`);
+    return;
+  }
+  if (typeof value === "string") {
+    const text2 = value;
+    if (definition.type === "boolean" && (text2 === "true" || text2 === "false"))
+      value = text2 === "true";
+    if ((definition.type === "integer" || definition.type === "number") && text2.trim() !== "")
+      value = Number(text2);
+  }
+  if (definition.type === "boolean" && typeof value !== "boolean")
+    throw new DeploymentInputError(`deployment input ${name} must be boolean`);
+  if (definition.type === "integer" && (!Number.isSafeInteger(value) || Number(value) < (definition.minimum ?? Number.MIN_SAFE_INTEGER) || Number(value) > (definition.maximum ?? Number.MAX_SAFE_INTEGER)))
+    throw new DeploymentInputError(`deployment input ${name} must be a bounded integer`);
+  if (definition.type === "number" && (typeof value !== "number" || !Number.isFinite(value) || value < (definition.minimum ?? -Number.MAX_VALUE) || value > (definition.maximum ?? Number.MAX_VALUE)))
+    throw new DeploymentInputError(`deployment input ${name} must be a bounded number`);
+  if (definition.type === "enum" && (typeof value !== "string" || !definition.values.includes(value)))
+    throw new DeploymentInputError(`deployment input ${name} must be one of its declared values`);
+  if (definition.type === "hostname" && (typeof value !== "string" || !HOSTNAME.test(value)))
+    throw new DeploymentInputError(`deployment input ${name} must be a hostname`);
+  if (definition.type === "string") {
+    if (typeof value !== "string" || value.length < (definition.minimumLength ?? 0) || value.length > (definition.maximumLength ?? 4096))
+      throw new DeploymentInputError(`deployment input ${name} must be a bounded string`);
+    if (definition.pattern !== undefined && !new RegExp(definition.pattern).test(value))
+      throw new DeploymentInputError(`deployment input ${name} does not match its pattern`);
+  }
+  return value;
+}
+function resolveDeploymentTargets(plan, supplied = {}) {
+  const inputs = resolveDeploymentInputs(plan, supplied);
+  const stringCoordinate = (value, label) => {
+    const resolved = typeof value === "string" ? value : value.$ref.startsWith("inputs.") ? inputs[value.$ref.slice("inputs.".length)] : undefined;
+    if (typeof resolved !== "string" || resolved.length < 1 || resolved.length > 253) {
+      throw new DeploymentInputError(`${label} did not resolve to a bounded string`);
+    }
+    return resolved.toLowerCase();
+  };
+  const integerCoordinate = (value, label, minimum, maximum) => {
+    const resolved = typeof value === "number" ? value : value.$ref.startsWith("inputs.") ? inputs[value.$ref.slice("inputs.".length)] : undefined;
+    if (!Number.isSafeInteger(resolved) || Number(resolved) < minimum || Number(resolved) > maximum) {
+      throw new DeploymentInputError(`${label} did not resolve to a bounded integer`);
+    }
+    return Number(resolved);
+  };
+  const credentialSource = (alias, label) => {
+    const source = plan.spec.credentials?.[alias]?.source.name;
+    if (!source)
+      throw new DeploymentInputError(`${label} did not resolve to a declared Vault credential`);
+    return source;
+  };
+  return Object.entries(plan.spec.targets).map(([name, target]) => {
+    const desired = typeof target.cardinality.desired === "number" ? target.cardinality.desired : target.cardinality.desired.$ref.startsWith("inputs.") ? inputs[target.cardinality.desired.$ref.slice("inputs.".length)] : undefined;
+    if (!Number.isSafeInteger(desired) || Number(desired) < target.cardinality.minimum || Number(desired) > target.cardinality.maximum) {
+      throw new DeploymentInputError(`target ${name} desired cardinality did not resolve to a bounded integer`);
+    }
+    let connectivity;
+    if (target.connectivity) {
+      const privateNetwork = target.connectivity.private;
+      const publicNetwork = target.connectivity.public;
+      connectivity = {
+        ...privateNetwork ? { private: privateNetwork.mode === "cloudflare-warp" ? {
+          mode: "cloudflare-warp",
+          credential: credentialSource(privateNetwork.credential, `target ${name} WARP credential`),
+          network: stringCoordinate(privateNetwork.network, `target ${name} WARP network`)
+        } : { mode: privateNetwork.mode } } : {},
+        ...publicNetwork ? { public: publicNetwork.mode === "cloudflare-tunnel" ? {
+          mode: "cloudflare-tunnel",
+          credential: credentialSource(publicNetwork.credential, `target ${name} Tunnel credential`),
+          zone: stringCoordinate(publicNetwork.zone, `target ${name} Tunnel zone`),
+          hostname: publicNetwork.hostname.mode === "static" ? {
+            mode: "static",
+            label: stringCoordinate(publicNetwork.hostname.label, `target ${name} Tunnel label`)
+          } : {
+            mode: "indexed",
+            prefix: stringCoordinate(publicNetwork.hostname.prefix, `target ${name} Tunnel prefix`),
+            startAt: publicNetwork.hostname.startAt ?? 1
+          },
+          service: (() => {
+            const applications = Object.values(plan.spec.components).filter((component2) => component2.target === name && component2.kind === "application" && component2.network?.public?.mode === "cloudflare-tunnel");
+            if (applications.length !== 1)
+              throw new DeploymentInputError(`target ${name} Tunnel requires exactly one public application`);
+            const port = applications[0].network.ingress?.stablePort;
+            if (!Number.isInteger(port))
+              throw new DeploymentInputError(`target ${name} Tunnel application requires a stable ingress port`);
+            return { protocol: "http", port: Number(port) };
+          })()
+        } : { mode: "disabled" } } : {}
+      };
+    }
+    return {
+      name,
+      profiles: [...target.selector.profiles],
+      operatingSystem: { ...target.selector.operatingSystem },
+      confidentialCompute: target.selector.confidentialCompute ?? "disabled",
+      labels: { ...target.selector.labels ?? {} },
+      minimum: target.cardinality.minimum,
+      desired: Number(desired),
+      maximum: target.cardinality.maximum,
+      allocation: {
+        ...target.allocation,
+        resources: {
+          cpuCores: integerCoordinate(target.allocation.resources.cpuCores, `target ${name} cpuCores`, 1, 1024),
+          memoryMiB: integerCoordinate(target.allocation.resources.memoryMiB, `target ${name} memoryMiB`, 128, 4194304),
+          storageGiB: integerCoordinate(target.allocation.resources.storageGiB, `target ${name} storageGiB`, 1, 1048576)
+        }
+      },
+      ...target.provisioning ? { provisioning: { ...target.provisioning } } : {},
+      ...connectivity ? { connectivity } : {}
+    };
+  });
+}
+function resolveDeploymentInputs(plan, supplied = {}) {
+  for (const name of Object.keys(supplied))
+    if (!(name in (plan.spec.inputs ?? {}))) {
+      throw new DeploymentInputError(`deployment input ${name} is not declared`);
+    }
+  const inputs = {};
+  for (const [name, definition] of Object.entries(plan.spec.inputs ?? {})) {
+    const value = inputValue(name, definition, supplied[name]);
+    if (value !== undefined)
+      inputs[name] = value;
+  }
+  return inputs;
+}
+
 // src/deploy-plan-runner.ts
 class DeploymentActionError extends Error {
   kind;
@@ -6906,6 +7421,8 @@ function resolveReference(reference2, state) {
     return nested(state.plan.spec.targets[parts[1]], parts.slice(2));
   if (parts[0] === "deployment")
     return nested(state.plan, parts.slice(1));
+  if (parts[0] === "execution")
+    return nested(state.execution, parts.slice(1));
   return;
 }
 function resolveOperand(value, state) {
@@ -7108,7 +7625,7 @@ async function runDeploymentPlan(options) {
   for (const [name, definition] of Object.entries(inputDefinitions))
     inputValues[name] = validateInputValue(definition, supplied[name], name);
   const execute = async () => {
-    const state = { inputs: inputValues, steps: new Map, plan };
+    const state = { inputs: inputValues, steps: new Map, plan, execution: options.execution };
     const records = [];
     const successful2 = [];
     for (const stage2 of workflow.stages) {
@@ -7163,7 +7680,7 @@ var DEPLOY_PLAN_FILE = ".fz/deploy.plan.json";
 import { createHash as createHash4, randomBytes as randomBytes5 } from "crypto";
 import {
   chmodSync as chmodSync3,
-  createReadStream,
+  createReadStream as createReadStream2,
   existsSync as existsSync3,
   lstatSync,
   mkdirSync as mkdirSync2,
@@ -7178,7 +7695,7 @@ var MAX_BOOTSTRAP_BUNDLE_BYTES = 512 * 1024 * 1024;
 async function sha256File(path2) {
   const hash = createHash4("sha256");
   await new Promise((resolveDone, reject) => {
-    const stream = createReadStream(path2);
+    const stream = createReadStream2(path2);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", resolveDone);
@@ -7264,7 +7781,7 @@ function persistCapacityCalibration(args) {
     throw new DeploymentError("PIPELINE_FAILED", "capacity evidence directory must be an absolute Agent-owned path");
   }
   if (!existsSync4(args.directory)) {
-    const parent = lstatSync2(dirname(args.directory));
+    const parent = lstatSync2(dirname2(args.directory));
     if (!parent.isDirectory() || parent.isSymbolicLink()) {
       throw new DeploymentError("PIPELINE_FAILED", "capacity evidence parent must be a real Agent-owned directory");
     }
@@ -7328,7 +7845,7 @@ function createDeploymentManager(options) {
     }
     if (existsSync4(knownHostsPath) && readFileSync3(knownHostsPath, "utf8") === content)
       return;
-    mkdirSync3(dirname(knownHostsPath), { recursive: true, mode: 448 });
+    mkdirSync3(dirname2(knownHostsPath), { recursive: true, mode: 448 });
     const next = `${knownHostsPath}.${process.pid}.${randomUUID()}.next`;
     writeFileSync3(next, content, { mode: 384, flag: "wx" });
     renameSync3(next, knownHostsPath);
@@ -7515,8 +8032,8 @@ function createDeploymentManager(options) {
             throw new DeploymentError("PIPELINE_FAILED", "rolling/canary plans require a fenced multi-target rollout lease that this control protocol does not yet supply");
           }
         }
-      const targetNames = new Set(Object.entries(plan.spec.targets).filter(([, target]) => target.selector.profiles.includes(options.profile)).map(([name]) => name));
-      if (targetNames.size === 0)
+      const matchingTargetNames = Object.entries(plan.spec.targets).filter(([, target]) => target.selector.profiles.includes(options.profile)).map(([name]) => name);
+      if (matchingTargetNames.length === 0)
         throw new DeploymentError("PIPELINE_FAILED", `deployment plan has no target for profile ${options.profile}`);
       const assurance = plan.spec.security?.attestation ?? "disabled";
       if (assurance !== "disabled") {
@@ -7539,35 +8056,66 @@ function createDeploymentManager(options) {
         FZ_DEPLOY_PROFILE: options.profile,
         ...options.publicApiUrl ? { PUBLIC_API_URL: options.publicApiUrl } : {}
       };
-      const inputValues = {};
-      for (const [name, definition2] of Object.entries(plan.spec.inputs ?? {})) {
-        const raw = options.environment?.[name];
-        if (raw === undefined) {
-          if (definition2.default !== undefined)
-            inputValues[name] = definition2.default;
-          continue;
+      const resolvedTargets = resolveDeploymentTargets(plan, options.environment ?? {}).filter((target) => target.profiles.includes(options.profile));
+      const assigned = request.assignment;
+      let targetNames;
+      if (assigned) {
+        const selected = resolvedTargets.find(({ name }) => name === assigned.targetName);
+        const mismatches = [
+          !selected ? "target" : null,
+          assigned.definitionDigest !== plan.sourceDigest ? "digest" : null,
+          !Number.isSafeInteger(assigned.slot) || assigned.slot < 0 || selected && assigned.slot >= selected.maximum ? "slot" : null,
+          selected && (assigned.operatingSystem.id !== selected.operatingSystem.id || assigned.operatingSystem.version !== selected.operatingSystem.version || assigned.operatingSystem.architecture !== selected.operatingSystem.architecture) ? "operating-system" : null,
+          selected && assigned.confidentialCompute !== selected.confidentialCompute ? "confidential-compute" : null,
+          selected && assigned.execution !== selected.allocation.execution ? "execution" : null,
+          selected && assigned.sharing !== selected.allocation.sharing ? "sharing" : null,
+          selected && (assigned.resources.cpuCores !== selected.allocation.resources.cpuCores || assigned.resources.memoryMiB !== selected.allocation.resources.memoryMiB || assigned.resources.storageGiB !== selected.allocation.resources.storageGiB) ? "resources" : null
+        ].filter(Boolean);
+        if (!selected || mismatches.length > 0) {
+          throw new DeploymentError("PIPELINE_FAILED", `the control-plane target assignment does not match this exact deployment plan (${mismatches.join(", ")})`);
         }
-        inputValues[name] = definition2.type === "boolean" ? raw === "true" : definition2.type === "integer" || definition2.type === "number" ? Number(raw) : raw;
+        const expectedPrivate = selected.connectivity?.private;
+        const expectedPublic = selected.connectivity?.public;
+        const assignedPrivate = assigned.connectivity?.private;
+        const assignedPublic = assigned.connectivity?.public;
+        const publicMatches = expectedPublic?.mode === "cloudflare-tunnel" ? assignedPublic?.mode === "cloudflare-tunnel" && assignedPublic.credential === expectedPublic.credential && assignedPublic.service.protocol === expectedPublic.service.protocol && assignedPublic.service.port === expectedPublic.service.port && assignedPublic.hostname === (expectedPublic.hostname.mode === "static" ? `${expectedPublic.hostname.label}.${expectedPublic.zone}` : `${expectedPublic.hostname.prefix}${expectedPublic.hostname.startAt + assigned.slot}.${expectedPublic.zone}`) : expectedPublic?.mode === "disabled" ? assignedPublic?.mode === "disabled" : assignedPublic === undefined;
+        if (JSON.stringify(assignedPrivate) !== JSON.stringify(expectedPrivate) || !publicMatches) {
+          throw new DeploymentError("PIPELINE_FAILED", "the control-plane connectivity assignment does not match this target slot");
+        }
+        targetNames = new Set([assigned.targetName]);
+      } else {
+        if (matchingTargetNames.length !== 1) {
+          throw new DeploymentError("PIPELINE_FAILED", "an unassigned bootstrap claim must resolve to exactly one target for its profile");
+        }
+        targetNames = new Set(matchingTargetNames);
       }
-      const resolvedTargets = Object.entries(plan.spec.targets).filter(([, target]) => target.selector.profiles.includes(options.profile)).map(([name, target]) => {
-        const desired = typeof target.cardinality.desired === "number" ? target.cardinality.desired : target.cardinality.desired.$ref.startsWith("inputs.") ? inputValues[target.cardinality.desired.$ref.slice("inputs.".length)] : undefined;
-        if (!Number.isSafeInteger(desired) || Number(desired) < target.cardinality.minimum || Number(desired) > target.cardinality.maximum) {
-          throw new DeploymentError("PIPELINE_FAILED", `target ${name} desired cardinality did not resolve to a bounded integer`);
+      if (assigned)
+        Object.assign(phaseEnvironment2, {
+          FZ_TARGET_NAME: assigned.targetName,
+          FZ_TARGET_SLOT: String(assigned.slot),
+          FZ_TARGET_CPU_CORES: String(assigned.resources.cpuCores),
+          FZ_TARGET_MEMORY_MIB: String(assigned.resources.memoryMiB),
+          FZ_TARGET_STORAGE_GIB: String(assigned.resources.storageGiB),
+          FZ_TARGET_EXECUTION: assigned.execution
+        });
+      for (const targetName of targetNames) {
+        const capacity2 = resolvedTargets.find(({ name }) => name === targetName)?.allocation.resources;
+        if (!capacity2)
+          throw new DeploymentError("PIPELINE_FAILED", `target ${targetName} has no resolved capacity`);
+        const components = Object.values(plan.spec.components).filter(({ target }) => target === targetName);
+        const cpu = components.reduce((sum, component2) => sum + (component2.resources?.cpu?.limit ?? 0), 0);
+        const memoryMiB = components.reduce((sum, component2) => sum + (component2.resources?.memory?.limitMiB ?? 0), 0);
+        const ephemeralMiB = components.reduce((sum, component2) => sum + (component2.kind === "application" ? (component2.storage ?? []).reduce((storage, mount) => storage + (mount.class === "ephemeral" ? mount.sizeMiB : 0), 0) : 0), 0);
+        if (cpu > capacity2.cpuCores || memoryMiB > capacity2.memoryMiB || ephemeralMiB > capacity2.storageGiB * 1024) {
+          throw new DeploymentError("PIPELINE_FAILED", `component limits exceed the reserved capacity of target ${targetName}`);
         }
-        return {
-          name,
-          profiles: [...target.selector.profiles],
-          confidentialCompute: target.selector.confidentialCompute ?? "disabled",
-          labels: { ...target.selector.labels ?? {} },
-          minimum: target.cardinality.minimum,
-          desired: Number(desired),
-          maximum: target.cardinality.maximum
-        };
-      });
+      }
+      const inputValues = resolveDeploymentInputs(plan, options.environment ?? {});
       const projectExec2 = options.projectExec ?? spawnExact;
       const materializePlanArgv = (argv2) => argv2.map((argument) => {
-        if (argument === "${FZ_RELEASE}")
-          return release;
+        const coordinate = argument.match(/^\$\{(FZ_[A-Z0-9_]+)\}$/)?.[1];
+        if (coordinate && phaseEnvironment2[coordinate] !== undefined)
+          return phaseEnvironment2[coordinate];
         if (argument.includes("${")) {
           throw new DeploymentActionError("refused", `unsupported deployment argv coordinate ${argument}`);
         }
@@ -7576,6 +8124,8 @@ function createDeploymentManager(options) {
       const providerSoftware = {
         "forgezero.bun": "bun",
         "forgezero.docker": "docker",
+        "forgezero.containerd": "containerd",
+        "forgezero.kata": "kata-containers",
         "forgezero.nginx": "nginx",
         "forgezero.arangodb": "arangodb",
         "forgezero.cloudflared": "cloudflared",
@@ -7601,6 +8151,29 @@ function createDeploymentManager(options) {
           await options.ensureSoftware(requirements);
           return { changed: true };
         },
+        "forgezero.network/ensure@1": async ({ resolved }) => {
+          if (!assigned || typeof resolved.target !== "string" || resolved.target !== assigned.targetName) {
+            throw new DeploymentActionError("refused", "network.ensure must target this exact control-plane assignment");
+          }
+          if (!assigned.connectivity)
+            return { changed: false, evidence: { target: assigned.targetName } };
+          if (!options.ensureSoftware || !options.applyConnectivity) {
+            throw new DeploymentActionError("provider-unavailable", "the supervised connectivity helper is unavailable");
+          }
+          const requirements = [];
+          if (assigned.connectivity.public?.mode === "cloudflare-tunnel")
+            requirements.push({ id: "cloudflared", version: "latest" });
+          if (assigned.connectivity.private?.mode === "cloudflare-warp")
+            requirements.push({ id: "cloudflare-warp", version: "latest" });
+          if (requirements.length > 0)
+            await options.ensureSoftware(requirements);
+          const evidence = await options.applyConnectivity({
+            key: `${options.key}:${assigned.targetName}:${assigned.slot}`,
+            intent: assigned.connectivity,
+            capabilities: request.connectivityCapabilities ?? {}
+          });
+          return { changed: true, evidence: structuredClone(evidence) };
+        },
         "forgezero.exec/argv@1": async ({ resolved, step: step2 }) => {
           if (!Array.isArray(resolved.argv) || resolved.argv.some((value) => typeof value !== "string"))
             throw new DeploymentActionError("refused", "exec.argv requires an exact argv array");
@@ -7642,7 +8215,7 @@ function createDeploymentManager(options) {
           const component2 = plan.spec.components[String(resolved.component ?? "")];
           const mounts = component2?.kind === "database" ? [component2.storage] : component2?.storage ?? [];
           for (const mount of mounts) {
-            const candidate = existsSync4(mount.path) ? mount.path : dirname(mount.path);
+            const candidate = existsSync4(mount.path) ? mount.path : dirname2(mount.path);
             const stats = statfsSync(candidate);
             const freePercent = Number(stats.bavail) / Number(stats.blocks) * 100;
             const minimum = mount.class === "ephemeral" ? 0 : mount.minimumFreePercent ?? 0;
@@ -7699,6 +8272,23 @@ function createDeploymentManager(options) {
         workflow: "deploy",
         inputs: inputValues,
         actions: actions2,
+        execution: assigned ? {
+          targetName: assigned.targetName,
+          slot: assigned.slot,
+          releaseExecutor: request.releaseExecutor === true,
+          runtime: assigned.execution,
+          cpuCores: assigned.resources.cpuCores,
+          memoryMiB: assigned.resources.memoryMiB,
+          storageGiB: assigned.resources.storageGiB
+        } : {
+          targetName: matchingTargetNames[0],
+          slot: 0,
+          releaseExecutor: request.releaseExecutor === true,
+          runtime: resolvedTargets[0].allocation.execution,
+          cpuCores: resolvedTargets[0].allocation.resources.cpuCores,
+          memoryMiB: resolvedTargets[0].allocation.resources.memoryMiB,
+          storageGiB: resolvedTargets[0].allocation.resources.storageGiB
+        },
         shouldRun: (step2) => step2.scope.kind === "release-executor" || step2.scope.kind === "elected-one" ? request.releaseExecutor === true : targetNames.has(step2.scope.target)
       });
       const phase = {
@@ -8060,7 +8650,12 @@ async function deployClaim(options, claim) {
   schedule();
   let result;
   try {
-    const run2 = () => manager.deploy({ revision: claim.revision, releaseExecutor: claim.releaseExecutor }).result;
+    const run2 = () => manager.deploy({
+      revision: claim.revision,
+      releaseExecutor: claim.releaseExecutor,
+      ...claim.assignment ? { assignment: claim.assignment } : {},
+      ...claim.connectivityCapabilities ? { connectivityCapabilities: claim.connectivityCapabilities } : {}
+    }).result;
     result = options.telemetry ? await options.telemetry.observe("deployment.run", run2) : await run2();
   } finally {
     stopped = true;
@@ -8130,7 +8725,11 @@ async function pullDeploymentOnce(options) {
     ...result.resolvedTargets ? { resolvedTargets: result.resolvedTargets.map((target) => ({
       ...target,
       profiles: [...target.profiles],
-      labels: { ...target.labels }
+      operatingSystem: { ...target.operatingSystem },
+      labels: { ...target.labels },
+      allocation: { ...target.allocation, resources: { ...target.allocation.resources } },
+      ...target.provisioning ? { provisioning: { ...target.provisioning } } : {},
+      ...target.connectivity ? { connectivity: structuredClone(target.connectivity) } : {}
     })) } : {},
     ...result.capacity ? { capacity: {
       recommendedConcurrency: result.capacity.recommendedConcurrency,
@@ -8186,11 +8785,11 @@ import {
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   renameSync as renameSync4,
-  statSync,
+  statSync as statSync2,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 function privateNetworkAttachmentFromEnvironment(env = process.env) {
   const values = {
     accountId: env.FZ_CF_ACCOUNT_ID?.trim() ?? "",
@@ -8220,7 +8819,7 @@ var validBinding = (value, expectedNodeKey) => {
 function loadGuestBinding(path2, expectedNodeKey) {
   if (!existsSync6(path2))
     return null;
-  const mode = statSync(path2).mode & 511;
+  const mode = statSync2(path2).mode & 511;
   if ((mode & 63) !== 0) {
     throw new Error(`guest enrolment state at ${path2} is not private`);
   }
@@ -8236,7 +8835,7 @@ function loadGuestBinding(path2, expectedNodeKey) {
   return parsed;
 }
 function persistGuestBinding(path2, binding) {
-  mkdirSync4(dirname2(path2), { recursive: true, mode: 448 });
+  mkdirSync4(dirname3(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.next`;
   writeFileSync4(temporary, `${JSON.stringify(binding)}
 `, { mode: 384 });
@@ -8587,8 +9186,14 @@ import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 import { fileURLToPath } from "url";
 
+// src/process-input.ts
+async function writeAndCloseProcessInput(input, value) {
+  input.write(value);
+  await input.end();
+}
+
 // src/version.ts
-var VERSION2 = "0.1.74";
+var VERSION2 = "0.1.76";
 
 // src/ssh-bootstrap.ts
 class SshBootstrapError extends Error {
@@ -8606,8 +9211,7 @@ var defaultExec = async (argv2, options = {}) => {
     env: { PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", LANG: "C", LC_ALL: "C" }
   });
   if (options.stdin !== undefined && child.stdin && typeof child.stdin !== "number") {
-    child.stdin.write(options.stdin);
-    child.stdin.end();
+    await writeAndCloseProcessInput(child.stdin, options.stdin);
   }
   const [stdout, stderr, exitCode] = await Promise.all([
     new Response(child.stdout).text(),
@@ -9304,11 +9908,11 @@ import {
   readFileSync as readFileSync6,
   readdirSync,
   rmSync as rmSync4,
-  statSync as statSync2,
+  statSync as statSync3,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join4 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join4 } from "path";
 import { isIP as isIP2 } from "net";
 
 // src/compute.ts
@@ -9733,7 +10337,7 @@ async function provisionMetalGuest(profile, claim, exec) {
   if (!image || !isAbsolute3(image.path) || !SHA256.test(image.sha256)) {
     throw new MetalProvisionError(`image ${claim.spec.imageKey} is not configured locally`);
   }
-  if (!statSync2(image.path).isFile())
+  if (!statSync3(image.path).isFile())
     throw new MetalProvisionError("configured image is not a file");
   const digest = (await checked2(exec, ["sha256sum", image.path])).stdout.trim().split(/\s+/)[0];
   if (digest !== image.sha256)
@@ -9818,7 +10422,7 @@ async function provisionMetalGuest(profile, claim, exec) {
   }
   const service = `forgezero-guest@${name}.service`;
   const unitPath = join4(profile.unitDir, service);
-  mkdirSync5(dirname3(unitPath), { recursive: true });
+  mkdirSync5(dirname4(unitPath), { recursive: true });
   writeFileSync6(unitPath, guestUnit(spec), { mode: 420 });
   await checked2(exec, ["systemctl", "daemon-reload"]);
   if (prior?.phase === "running") {
@@ -10882,7 +11486,7 @@ import {
   symlinkSync as symlinkSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
+import { dirname as dirname5, join as join7, resolve as resolve2 } from "path";
 var DEFAULT_AGENT_RELEASE_ROOT = "/opt/forgezero/agent";
 var DEFAULT_AGENT_UPDATE_SOCKET = "/run/forgezero-update/helper.sock";
 var MAX_AGENT_TARBALL_BYTES = 32 * 1024 * 1024;
@@ -10904,7 +11508,7 @@ var syncReleaseDirectory = (directory) => {
     join7(directory, "dist", "fz-git-ssh.js"),
     join7(directory, "dist"),
     directory,
-    dirname4(directory)
+    dirname5(directory)
   ])
     syncPath(path2);
 };
@@ -11026,7 +11630,7 @@ async function stageAgentRelease(releaseInput, options) {
         args: ["-xOzf", archive, member]
       }, `agent update extraction of ${member}`);
       const destination = join7(unpacked, relative);
-      mkdirSync8(dirname4(destination), { recursive: true, mode: 448 });
+      mkdirSync8(dirname5(destination), { recursive: true, mode: 448 });
       writeFileSync9(destination, extracted.output, { mode: 384, flag: "wx" });
     }
     await validateReleaseDirectory(unpacked, release, run2);
@@ -11058,21 +11662,21 @@ async function stageAgentRelease(releaseInput, options) {
   }
 }
 function selectAgentRelease(staged) {
-  const next = join7(dirname4(staged.currentLink), `.current.${randomUUID2()}.next`);
+  const next = join7(dirname5(staged.currentLink), `.current.${randomUUID2()}.next`);
   try {
     symlinkSync3(staged.nextTarget, next);
     renameSync6(next, staged.currentLink);
-    syncPath(dirname4(staged.currentLink));
+    syncPath(dirname5(staged.currentLink));
   } finally {
     rmSync5(next, { force: true });
   }
 }
 function restoreAgentRelease(staged) {
-  const next = join7(dirname4(staged.currentLink), `.current.${randomUUID2()}.rollback`);
+  const next = join7(dirname5(staged.currentLink), `.current.${randomUUID2()}.rollback`);
   try {
     symlinkSync3(staged.previousTarget, next);
     renameSync6(next, staged.currentLink);
-    syncPath(dirname4(staged.currentLink));
+    syncPath(dirname5(staged.currentLink));
   } finally {
     rmSync5(next, { force: true });
   }
@@ -11094,7 +11698,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { connect as connect5, createServer as createServer6 } from "net";
-import { dirname as dirname5, join as join8, resolve as resolve3 } from "path";
+import { dirname as dirname6, join as join8, resolve as resolve3 } from "path";
 var AGENT_UPDATE_GROUP = "forgezero-update";
 var AGENT_UPDATE_HELPER_UNIT_PATH = "/etc/systemd/system/forgezero-agent-update-helper.service";
 var AGENT_UPDATE_JOURNAL = "/var/lib/forgezero/agent-update.json";
@@ -11194,7 +11798,7 @@ function readJournal(path2, root) {
   return validateJournal(JSON.parse(readFileSync10(path2, "utf8")), root);
 }
 function writeAtomic(path2, value, mode) {
-  mkdirSync9(dirname5(path2), { recursive: true, mode: 493 });
+  mkdirSync9(dirname6(path2), { recursive: true, mode: 493 });
   const next = `${path2}.${randomUUID3()}.next`;
   let file;
   try {
@@ -11205,7 +11809,7 @@ function writeAtomic(path2, value, mode) {
     closeSync3(file);
     file = undefined;
     renameSync7(next, path2);
-    const directory = openSync3(dirname5(path2), "r");
+    const directory = openSync3(dirname6(path2), "r");
     try {
       fsyncSync2(directory);
     } finally {
@@ -11327,7 +11931,7 @@ async function activateAgentRelease(staged, options = {}) {
   const now = options.now ?? Date.now;
   const journalPath = options.journalPath ?? AGENT_UPDATE_JOURNAL;
   const receiptPath = options.receiptPath ?? AGENT_UPDATE_RECEIPT;
-  const previous = readJournal(journalPath, dirname5(staged.currentLink));
+  const previous = readJournal(journalPath, dirname6(staged.currentLink));
   const attemptId = options.attemptId ?? randomUUID3();
   if (!ATTEMPT_ID.test(attemptId))
     throw new Error("Agent update attempt ID is invalid");
@@ -11435,7 +12039,7 @@ function startAgentUpdateHelper(options = {}) {
   const socketPath = options.socketPath ?? DEFAULT_AGENT_UPDATE_SOCKET;
   if (existsSync13(socketPath))
     unlinkSync10(socketPath);
-  mkdirSync9(dirname5(socketPath), { recursive: true, mode: 488 });
+  mkdirSync9(dirname6(socketPath), { recursive: true, mode: 488 });
   const setTimer = options.setTimer ?? ((callback, ms) => setTimeout(callback, ms));
   const receiptPath = options.receiptPath ?? AGENT_UPDATE_RECEIPT;
   const journalPath = options.journalPath ?? AGENT_UPDATE_JOURNAL;
@@ -11544,23 +12148,63 @@ function requestAgentUpdate(request, socketPath = DEFAULT_AGENT_UPDATE_SOCKET, t
 }
 
 // src/agent-heartbeat.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, statfsSync as statfsSync2 } from "fs";
+import { cpus, freemem, loadavg, totalmem } from "os";
+function readAgentHostMetrics() {
+  const filesystem = statfsSync2("/");
+  return {
+    logicalCpu: cpus().length,
+    memoryBytes: totalmem(),
+    memoryFreeBytes: freemem(),
+    storageBytes: Number(filesystem.blocks) * Number(filesystem.bsize),
+    storageFreeBytes: Number(filesystem.bavail) * Number(filesystem.bsize),
+    load1m: loadavg()[0]
+  };
+}
 var unquote = (value) => value.replace(/^['"]|['"]$/g, "");
 var remoteOutcome4 = (cause) => cause instanceof SignedNodeHttpError && cause.status < 500 ? "refused" : cause instanceof SignedNodeHttpError ? "retryable" : "failed";
 
 class AgentUpdateRefusedError extends Error {
 }
-function observeAgentHost(version = VERSION2, mode = "enrolled", osRelease = readFileSync11("/etc/os-release", "utf8"), architecture = process.arch) {
+function observeAgentHost(version = VERSION2, mode = "enrolled", osRelease = readFileSync11("/etc/os-release", "utf8"), architecture = process.arch, metrics = readAgentHostMetrics()) {
   const values = Object.fromEntries(osRelease.split(`
 `).flatMap((line) => {
     const separator = line.indexOf("=");
     return separator > 0 ? [[line.slice(0, separator), unquote(line.slice(separator + 1))]] : [];
   }));
+  const osId = (values.ID ?? "unknown").toLowerCase();
+  const osVersion = values.VERSION_ID ?? "unknown";
+  const ubuntuX64 = osId === "ubuntu" && ["24.04", "26.04"].includes(osVersion) && architecture === "x64";
+  const enabled = (path2) => {
+    try {
+      return /^(?:1|y)$/i.test(readFileSync11(path2, "utf8").trim());
+    } catch {
+      return false;
+    }
+  };
+  const gib = 1024 ** 3;
+  const mib = 1024 ** 2;
+  const storageGiB = Math.max(1, Math.floor(metrics.storageBytes / gib));
   return {
     version,
-    os: { id: (values.ID ?? "unknown").toLowerCase(), versionId: values.VERSION_ID ?? "unknown" },
+    os: { id: osId, versionId: osVersion },
     architecture,
-    mode
+    mode,
+    runtimeCapabilities: {
+      native: true,
+      ociRunc: ubuntuX64,
+      kataQemuSnp: ubuntuX64 && osVersion === "26.04" && existsSync14("/dev/kvm") && existsSync14("/dev/sev") && enabled("/sys/module/kvm_amd/parameters/sev") && enabled("/sys/module/kvm_amd/parameters/sev_snp")
+    },
+    capacity: {
+      logicalCpu: Math.max(1, metrics.logicalCpu),
+      memoryMiB: Math.max(1, Math.floor(metrics.memoryBytes / mib)),
+      storageGiB
+    },
+    utilization: {
+      load1mMilli: Math.max(0, Math.round(metrics.load1m * 1000)),
+      memoryUsedMiB: Math.max(0, Math.floor((metrics.memoryBytes - metrics.memoryFreeBytes) / mib)),
+      storageUsedGiB: Math.max(0, Math.min(storageGiB, Math.ceil((metrics.storageBytes - metrics.storageFreeBytes) / gib)))
+    }
   };
 }
 async function heartbeatAgentOnce(options) {
@@ -11668,14 +12312,14 @@ function startAgentHeartbeat(options) {
 }
 
 // src/software-helper.ts
-import { chmodSync as chmodSync14, existsSync as existsSync16, mkdirSync as mkdirSync12, unlinkSync as unlinkSync11 } from "fs";
+import { chmodSync as chmodSync14, existsSync as existsSync17, mkdirSync as mkdirSync13, unlinkSync as unlinkSync11 } from "fs";
 import { connect as connect6, createServer as createServer7 } from "net";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname10 } from "path";
 
 // src/service-supervisor.ts
 import { createHash as createHash9 } from "crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync12, readdirSync as readdirSync2, realpathSync as realpathSync2, renameSync as renameSync8, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname6, join as join9, resolve as resolve4, sep as sep2 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync12, readdirSync as readdirSync2, realpathSync as realpathSync2, renameSync as renameSync8, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname7, join as join9, resolve as resolve4, sep as sep2 } from "path";
 var SERVICE_STATE_DIRECTORY = "/var/lib/forgezero/services";
 var SERVICE_CONFIG_DIRECTORY = "/etc/forgezero/services";
 var SERVICE_UNIT_DIRECTORY = "/etc/systemd/system";
@@ -11685,14 +12329,14 @@ var statePath = (id2) => `${SERVICE_STATE_DIRECTORY}/${id2}.json`;
 var within2 = (root, path2) => path2 === root || path2.startsWith(`${root}${sep2}`);
 var defaultHost = {
   write(path2, content, mode) {
-    mkdirSync10(dirname6(path2), { recursive: true, mode: 493 });
+    mkdirSync10(dirname7(path2), { recursive: true, mode: 493 });
     const next = `${path2}.next`;
     writeFileSync11(next, content, { mode });
     renameSync8(next, path2);
   },
   read: (path2) => readFileSync12(path2, "utf8"),
-  exists: existsSync14,
-  list: (path2) => existsSync14(path2) ? readdirSync2(path2) : [],
+  exists: existsSync15,
+  list: (path2) => existsSync15(path2) ? readdirSync2(path2) : [],
   realpath: realpathSync2,
   mkdir: (path2, mode) => mkdirSync10(path2, { recursive: true, mode }),
   remove: (path2) => rmSync7(path2, { force: true }),
@@ -11891,20 +12535,20 @@ async function activateSupervisedService(request, host = defaultHost) {
 
 // src/container-supervisor.ts
 import { createHash as createHash10 } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync13, readdirSync as readdirSync3, realpathSync as realpathSync3, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname7, resolve as resolve5, sep as sep3 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync13, readdirSync as readdirSync3, realpathSync as realpathSync3, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname8, resolve as resolve5, sep as sep3 } from "path";
 var defaultHost2 = {
   realpath: realpathSync3,
-  exists: existsSync15,
+  exists: existsSync16,
   read: (path2) => readFileSync13(path2, "utf8"),
   write(path2, content, mode) {
-    mkdirSync11(dirname7(path2), { recursive: true, mode: 493 });
+    mkdirSync11(dirname8(path2), { recursive: true, mode: 493 });
     const next = `${path2}.next`;
     writeFileSync12(next, content, { mode });
     renameSync9(next, path2);
   },
   remove: (path2) => rmSync8(path2, { force: true }),
-  list: (path2) => existsSync15(path2) ? readdirSync3(path2) : [],
+  list: (path2) => existsSync16(path2) ? readdirSync3(path2) : [],
   mkdir: (path2, mode) => mkdirSync11(path2, { recursive: true, mode }),
   async exec(argv2) {
     const child = Bun.spawn([...argv2], { stdout: "pipe", stderr: "pipe", env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", LANG: "C", LC_ALL: "C" } });
@@ -11926,6 +12570,38 @@ var within3 = (root, path2) => path2 === root || path2.startsWith(`${root}${sep3
 var idFor2 = (key) => createHash10("sha256").update(key).digest("hex").slice(0, 24);
 var statePath2 = (id2) => `${SERVICE_STATE_DIRECTORY}/${id2}.json`;
 var nameFor = (id2, slot) => `forgezero-${id2}-slot${slot}`;
+function backendFor(application) {
+  const runtime = application.runtime;
+  if (runtime.kind !== "container")
+    throw new Error("CONTAINER_RUNTIME_REQUIRED");
+  if (runtime.provider === "forgezero.docker") {
+    if (runtime.runtimeClass && runtime.runtimeClass !== "runc")
+      throw new Error("CONTAINER_RUNTIME_PROVIDER_MISMATCH");
+    return { engine: "docker", runtimeClass: "runc", prefix: ["/usr/bin/docker"] };
+  }
+  if (runtime.provider === "forgezero.containerd") {
+    if ((runtime.runtimeClass ?? "runc") !== "runc")
+      throw new Error("CONTAINER_RUNTIME_PROVIDER_MISMATCH");
+    return {
+      engine: "containerd",
+      runtimeClass: "runc",
+      prefix: ["/usr/local/bin/nerdctl", "--namespace", "forgezero"],
+      runtimeName: "io.containerd.runc.v2"
+    };
+  }
+  if (runtime.provider === "forgezero.kata") {
+    if (runtime.runtimeClass !== "kata-qemu-snp")
+      throw new Error("CONTAINER_RUNTIME_PROVIDER_MISMATCH");
+    return {
+      engine: "containerd",
+      runtimeClass: "kata-qemu-snp",
+      prefix: ["/usr/local/bin/nerdctl", "--namespace", "forgezero"],
+      runtimeName: "io.containerd.kata.v2"
+    };
+  }
+  throw new Error("CONTAINER_RUNTIME_PROVIDER_UNSUPPORTED");
+}
+var command2 = (backend, ...argv2) => [...backend.prefix, ...argv2];
 function validateRequest(request, host) {
   if (!/^[A-Za-z0-9][A-Za-z0-9_.:@/-]{0,255}$/.test(request.key) || !/^[a-f0-9]{40}$/.test(request.revision) || !/^[a-z][A-Za-z0-9-]{0,62}$/.test(request.component))
     throw new Error("CONTAINER_IDENTITY_INVALID");
@@ -11936,6 +12612,7 @@ function validateRequest(request, host) {
   const application = request.application;
   if (application.kind !== "application" || application.runtime.kind !== "container")
     throw new Error("CONTAINER_RUNTIME_REQUIRED");
+  backendFor(application);
   if (!application.resources.cpu || !application.resources.memory || !application.resources.pids)
     throw new Error("CONTAINER_LIMITS_REQUIRED");
   if (application.runtime.security.privileged !== false || application.runtime.security.noNewPrivileges !== true || !application.runtime.security.dropCapabilities.includes("ALL"))
@@ -11957,12 +12634,13 @@ async function buildContainerImage(requestValue, host = defaultHost2) {
   const runtime = request.application.runtime;
   if (runtime.kind !== "container")
     throw new Error("CONTAINER_RUNTIME_REQUIRED");
+  const backend = backendFor(request.application);
   const source = runtime.image.source;
   if (source.kind === "registry") {
     if (!source.reference.includes("@sha256:"))
       throw new Error("CONTAINER_IMAGE_DIGEST_REQUIRED");
-    await checked6(host, ["/usr/bin/docker", "pull", "--quiet", source.reference], "CONTAINER_PULL_FAILED");
-    const digest2 = await checked6(host, ["/usr/bin/docker", "image", "inspect", "--format={{.Id}}", source.reference], "CONTAINER_INSPECT_FAILED");
+    await checked6(host, command2(backend, "pull", "--quiet", source.reference), "CONTAINER_PULL_FAILED");
+    const digest2 = await checked6(host, command2(backend, "image", "inspect", "--format={{.Id}}", source.reference), "CONTAINER_INSPECT_FAILED");
     if (!/^sha256:[a-f0-9]{64}$/.test(digest2))
       throw new Error("CONTAINER_DIGEST_INVALID");
     return { image: source.reference, digest: digest2 };
@@ -11972,22 +12650,8 @@ async function buildContainerImage(requestValue, host = defaultHost2) {
   if (!within3(request.release, context) || !within3(context, dockerfile))
     throw new Error("CONTAINER_BUILD_PATH_INVALID");
   const tag = `forgezero/${idFor2(request.key)}:${request.revision}`;
-  await checked6(host, [
-    "/usr/bin/docker",
-    "build",
-    "--pull",
-    ...request.noCache ? ["--no-cache"] : [],
-    "--file",
-    dockerfile,
-    "--tag",
-    tag,
-    "--label",
-    `net.forgezero.revision=${request.revision}`,
-    "--label",
-    `net.forgezero.component=${request.component}`,
-    context
-  ], "CONTAINER_BUILD_FAILED");
-  const digest = await checked6(host, ["/usr/bin/docker", "image", "inspect", "--format={{.Id}}", tag], "CONTAINER_INSPECT_FAILED");
+  await checked6(host, command2(backend, "build", "--pull", ...request.noCache ? ["--no-cache"] : [], "--file", dockerfile, "--tag", tag, "--label", `net.forgezero.revision=${request.revision}`, "--label", `net.forgezero.component=${request.component}`, context), "CONTAINER_BUILD_FAILED");
+  const digest = await checked6(host, command2(backend, "image", "inspect", "--format={{.Id}}", tag), "CONTAINER_INSPECT_FAILED");
   if (!/^sha256:[a-f0-9]{64}$/.test(digest))
     throw new Error("CONTAINER_DIGEST_INVALID");
   return { image: tag, digest };
@@ -12055,7 +12719,7 @@ ${service.websocket ? `    proxy_set_header Upgrade $http_upgrade;
 }
 `;
 }
-function runArgv(request, id2, slot, port, networkName) {
+function runArgv(request, backend, id2, slot, port, networkName) {
   const { application } = request;
   const resources = application.resources;
   const runtime = application.runtime;
@@ -12063,35 +12727,7 @@ function runArgv(request, id2, slot, port, networkName) {
     throw new Error("CONTAINER_RUNTIME_REQUIRED");
   const memory = resources.memory;
   const network = application.network.container;
-  const argv2 = [
-    "/usr/bin/docker",
-    "run",
-    "--detach",
-    "--name",
-    nameFor(id2, slot),
-    "--restart",
-    "unless-stopped",
-    "--label",
-    `net.forgezero.key=${request.key}`,
-    "--label",
-    `net.forgezero.revision=${request.revision}`,
-    "--cpus",
-    String(resources.cpu.limit),
-    "--cpu-shares",
-    String(resources.cpu.weight ?? 100),
-    "--memory",
-    `${memory.limitMiB}m`,
-    ...memory.reservationMiB ? ["--memory-reservation", `${memory.reservationMiB}m`] : [],
-    ...memory.swap === "disabled" ? ["--memory-swap", `${memory.limitMiB}m`] : [],
-    "--pids-limit",
-    String(resources.pids.limit),
-    "--security-opt",
-    "no-new-privileges=true",
-    "--cap-drop",
-    "ALL",
-    ...runtime.security.root === "read-only" ? ["--read-only"] : [],
-    ...network.mode === "host" ? ["--network", "host", "--env", `FZ_APP_PORT=${port}`] : ["--network", networkName, "--publish", `127.0.0.1:${port}:${application.service.port}`]
-  ];
+  const argv2 = command2(backend, "run", "--detach", "--name", nameFor(id2, slot), "--restart", "unless-stopped", "--label", `net.forgezero.key=${request.key}`, "--label", `net.forgezero.revision=${request.revision}`, ...backend.runtimeName ? ["--runtime", backend.runtimeName] : [], "--cpus", String(resources.cpu.limit), "--cpu-shares", String(resources.cpu.weight ?? 100), "--memory", `${memory.limitMiB}m`, ...memory.reservationMiB ? ["--memory-reservation", `${memory.reservationMiB}m`] : [], ...memory.swap === "disabled" ? ["--memory-swap", `${memory.limitMiB}m`] : [], "--pids-limit", String(resources.pids.limit), "--security-opt", "no-new-privileges=true", "--cap-drop", "ALL", ...runtime.security.root === "read-only" ? ["--read-only"] : [], ...network.mode === "host" ? ["--network", "host", "--env", `FZ_APP_PORT=${port}`] : ["--network", networkName, "--publish", `127.0.0.1:${port}:${application.service.port}`]);
   for (const mount of application.storage ?? []) {
     if (mount.class === "ephemeral")
       argv2.push("--tmpfs", `${mount.path}:rw,noexec,nosuid,size=${mount.sizeMiB}m`);
@@ -12105,6 +12741,7 @@ async function activateContainer(requestValue, host = defaultHost2) {
   const request = validateRequest(requestValue, host);
   if (!/^sha256:[a-f0-9]{64}$/.test(request.image) && !/^forgezero\/[a-f0-9]{24}:[a-f0-9]{40}$/.test(request.image) && !request.image.includes("@sha256:"))
     throw new Error("CONTAINER_IMAGE_INVALID");
+  const backend = backendFor(request.application);
   const id2 = idFor2(request.key);
   host.mkdir(SERVICE_STATE_DIRECTORY, 448);
   host.mkdir(SERVICE_NGINX_DIRECTORY, 493);
@@ -12117,9 +12754,9 @@ async function activateContainer(requestValue, host = defaultHost2) {
   if (containerNetwork.mode === "bridge") {
     networkName = containerNetwork.network ? `forgezero-${id2}-${containerNetwork.network}` : "bridge";
     if (networkName !== "bridge") {
-      const inspected = await host.exec(["/usr/bin/docker", "network", "inspect", '--format={{index .Labels "net.forgezero.owner"}}', networkName]);
+      const inspected = await host.exec(command2(backend, "network", "inspect", '--format={{index .Labels "net.forgezero.owner"}}', networkName));
       if (inspected.exitCode !== 0) {
-        await checked6(host, ["/usr/bin/docker", "network", "create", "--driver", "bridge", "--label", `net.forgezero.owner=${id2}`, networkName], "CONTAINER_NETWORK_CREATE_FAILED");
+        await checked6(host, command2(backend, "network", "create", "--driver", "bridge", "--label", `net.forgezero.owner=${id2}`, networkName), "CONTAINER_NETWORK_CREATE_FAILED");
       } else if (inspected.output.trim() !== id2)
         throw new Error("CONTAINER_NETWORK_OWNERSHIP_INVALID");
     }
@@ -12128,8 +12765,8 @@ async function activateContainer(requestValue, host = defaultHost2) {
   const nextSlot = slots === 2 && previous?.activeSlot === 0 ? 1 : 0;
   const port = ports[nextSlot];
   const name = nameFor(id2, nextSlot);
-  await host.exec(["/usr/bin/docker", "rm", "--force", name]);
-  await checked6(host, runArgv(request, id2, nextSlot, port, networkName), "CONTAINER_START_FAILED");
+  await host.exec(command2(backend, "rm", "--force", name));
+  await checked6(host, runArgv(request, backend, id2, nextSlot, port, networkName), "CONTAINER_START_FAILED");
   let healthy = false;
   const health = request.application.service.health;
   for (let attempt = 0;attempt < (health.attempts ?? 30); attempt += 1) {
@@ -12140,9 +12777,22 @@ async function activateContainer(requestValue, host = defaultHost2) {
     await host.sleep(health.intervalMs ?? 1000);
   }
   if (!healthy) {
-    await host.exec(["/usr/bin/docker", "rm", "--force", name]);
+    await host.exec(command2(backend, "rm", "--force", name));
     throw new Error("CONTAINER_HEALTH_FAILED");
   }
+  let runtimeEvidence;
+  if (backend.engine === "containerd") {
+    const raw = await checked6(host, ["/usr/bin/ctr", "--namespace", "forgezero", "containers", "info", name], "CONTAINER_RUNTIME_EVIDENCE_FAILED");
+    let observed = "";
+    try {
+      observed = String(JSON.parse(raw).Runtime?.Name ?? "");
+    } catch {
+      throw new Error("CONTAINER_RUNTIME_EVIDENCE_INVALID");
+    }
+    if (observed !== backend.runtimeName)
+      throw new Error("CONTAINER_RUNTIME_DOWNGRADE");
+    runtimeEvidence = observed;
+  }
   const nginxPath = `${SERVICE_NGINX_DIRECTORY}/forgezero-${id2}.conf`;
   const previousNginx = host.exists(nginxPath) ? host.read(nginxPath) : null;
   host.write(nginxPath, nginx2(request, id2, port), 420);
@@ -12156,7 +12806,7 @@ async function activateContainer(requestValue, host = defaultHost2) {
       host.write(nginxPath, previousNginx, 420);
     await host.exec(["/usr/sbin/nginx", "-t"]);
     await host.exec(["/usr/bin/systemctl", "reload", "nginx.service"]);
-    await host.exec(["/usr/bin/docker", "rm", "--force", name]);
+    await host.exec(command2(backend, "rm", "--force", name));
     throw cause;
   }
   const state = {
@@ -12169,17 +12819,167 @@ async function activateContainer(requestValue, host = defaultHost2) {
     applicationPorts: ports,
     activeSlot: nextSlot,
     healthPath: health.path,
+    containerRuntime: {
+      engine: backend.engine,
+      runtimeClass: backend.runtimeClass,
+      ...backend.engine === "containerd" ? { namespace: "forgezero", evidence: runtimeEvidence } : {}
+    },
     updatedAtTs: host.now()
   };
   host.write(statePath2(id2), `${JSON.stringify(state, null, 2)}
 `, 384);
   if (previous && previous.activeSlot !== nextSlot) {
     await host.sleep(request.application.rollout.drainMs ?? 30000);
-    await host.exec(["/usr/bin/docker", "rm", "--force", nameFor(id2, previous.activeSlot)]);
+    await host.exec(command2(backend, "rm", "--force", nameFor(id2, previous.activeSlot)));
   }
   return state;
 }
 
+// src/deployment-connectivity.ts
+import { createHash as createHash11 } from "crypto";
+import { mkdirSync as mkdirSync12, renameSync as renameSync10, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname9 } from "path";
+var TOKEN2 = /^[A-Za-z0-9._-]{40,16384}$/;
+var UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+var HOSTNAME2 = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var NAME3 = /^[a-z][a-z0-9._-]{0,99}$/;
+var idFor3 = (key) => createHash11("sha256").update(key).digest("hex").slice(0, 20);
+var checked7 = async (host, argv2, label) => {
+  const result = await host.exec(argv2);
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${result.output.slice(0, 512)}`);
+  return result.output.trim();
+};
+async function sealWithSystemd(name, path2, value) {
+  mkdirSync12(dirname9(path2), { recursive: true, mode: 448 });
+  const next = `${path2}.next`;
+  const child = Bun.spawn(["/usr/bin/systemd-creds", "encrypt", `--name=${name}`, "-", next], {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { PATH: "/usr/sbin:/usr/bin:/sbin:/bin", LANG: "C", LC_ALL: "C" }
+  });
+  await writeAndCloseProcessInput(child.stdin, value);
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`systemd credential sealing failed: ${`${stdout}${stderr}`.replaceAll(value, "[REDACTED]").slice(0, 512)}`);
+  renameSync10(next, path2);
+}
+var defaultHost3 = {
+  seal: sealWithSystemd,
+  write(path2, content, mode) {
+    mkdirSync12(dirname9(path2), { recursive: true, mode: 493 });
+    const next = `${path2}.next`;
+    writeFileSync13(next, content, { mode });
+    renameSync10(next, path2);
+  },
+  async exec(argv2) {
+    const child = Bun.spawn([...argv2], { stdout: "pipe", stderr: "pipe", env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", LANG: "C", LC_ALL: "C" } });
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    return { exitCode, output: `${stdout}${stderr}` };
+  },
+  sleep: (ms) => Bun.sleep(ms)
+};
+function validate2(request) {
+  if (!request.key || request.key.length > 256)
+    throw new Error("deployment connectivity key is invalid");
+  const publicIntent = request.intent.public;
+  const privateIntent = request.intent.private;
+  if (publicIntent?.mode === "cloudflare-tunnel") {
+    if (!NAME3.test(publicIntent.credential) || !HOSTNAME2.test(publicIntent.hostname) || !NAME3.test(publicIntent.tunnelKey) || publicIntent.service.protocol !== "http" || !Number.isInteger(publicIntent.service.port) || publicIntent.service.port < 1 || publicIntent.service.port > 65535 || !request.capabilities.public || !UUID.test(request.capabilities.public.tunnelId) || !TOKEN2.test(request.capabilities.public.connectorToken)) {
+      throw new Error("public deployment connectivity is malformed");
+    }
+  } else if (request.capabilities.public)
+    throw new Error("unexpected public deployment capability");
+  if (privateIntent?.mode === "cloudflare-warp") {
+    if (!NAME3.test(privateIntent.credential) || privateIntent.network.length < 1 || privateIntent.network.length > 128 || !request.capabilities.private || !UUID.test(request.capabilities.private.connectorId) || !TOKEN2.test(request.capabilities.private.connectorToken)) {
+      throw new Error("private deployment connectivity is malformed");
+    }
+  } else if (request.capabilities.private)
+    throw new Error("unexpected private deployment capability");
+}
+async function applyDeploymentConnectivity(request, host = defaultHost3) {
+  validate2(request);
+  const id2 = idFor3(request.key);
+  const evidence = { key: request.key };
+  if (request.intent.public?.mode === "cloudflare-tunnel") {
+    const capability = request.capabilities.public;
+    const credentialName = `FZ_TUNNEL_${id2.toUpperCase()}`;
+    const credentialPath = `/etc/forgezero/creds/deployment-tunnel-${id2}.cred`;
+    const unit2 = `forgezero-cloudflared-${id2}.service`;
+    const unitPath = `/etc/systemd/system/${unit2}`;
+    const metricsPort = 20000 + Number.parseInt(id2.slice(0, 4), 16) % 20000;
+    await host.seal(credentialName, credentialPath, capability.connectorToken);
+    host.write(unitPath, `[Unit]
+Description=ForgeZero deployment Tunnel ${id2}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+DynamicUser=yes
+LoadCredentialEncrypted=${credentialName}:${credentialPath}
+ExecStart=/usr/local/bin/cloudflared tunnel --no-autoupdate --metrics 127.0.0.1:${metricsPort} run --token-file %d/${credentialName}
+Restart=always
+RestartSec=5
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+
+[Install]
+WantedBy=multi-user.target
+`, 420);
+    await checked7(host, ["/usr/bin/systemctl", "daemon-reload"], "cloudflared daemon reload");
+    await checked7(host, ["/usr/bin/systemctl", "enable", "--now", unit2], "cloudflared start");
+    await checked7(host, ["/usr/bin/systemctl", "is-active", "--quiet", unit2], "cloudflared readiness");
+    evidence.public = { hostname: request.intent.public.hostname, tunnelId: capability.tunnelId, unit: unit2, active: true };
+  }
+  if (request.intent.private?.mode === "cloudflare-warp") {
+    const capability = request.capabilities.private;
+    const credentialPath = "/etc/forgezero/creds/CF_WARP_CONNECTOR_TOKEN.cred";
+    const unit2 = "forgezero-deployment-mesh.service";
+    await host.seal("CF_WARP_CONNECTOR_TOKEN", credentialPath, capability.connectorToken);
+    host.write(`/etc/systemd/system/${unit2}`, `[Unit]
+Description=ForgeZero deployment Mesh/WARP connector
+Requires=warp-svc.service
+After=network-online.target warp-svc.service
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+LoadCredentialEncrypted=CF_WARP_CONNECTOR_TOKEN:${credentialPath}
+ExecStart=/usr/local/bin/fz-agent mesh-config
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/lib/cloudflare-warp
+
+[Install]
+WantedBy=multi-user.target
+`, 420);
+    await checked7(host, ["/usr/bin/systemctl", "daemon-reload"], "WARP daemon reload");
+    await checked7(host, ["/usr/bin/systemctl", "enable", "--now", "warp-svc.service", unit2], "WARP connector start");
+    for (let attempt = 0;attempt < 10; attempt += 1) {
+      const status = await host.exec(["/usr/bin/warp-cli", "--accept-tos", "status"]);
+      if (status.exitCode === 0 && /\bconnected\b/i.test(status.output) && !/\bdisconnected\b/i.test(status.output)) {
+        evidence.private = { network: request.intent.private.network, connectorId: capability.connectorId, unit: unit2, active: true };
+        break;
+      }
+      await host.sleep(1000);
+    }
+    if (!evidence.private)
+      throw new Error("WARP connector readiness failed");
+  }
+  return evidence;
+}
+
 // src/software-helper.ts
 var DEFAULT_SOFTWARE_HELPER_SOCKET = "/run/forgezero-software/helper.sock";
 var SOFTWARE_HELPER_GROUP = "forgezero-software";
@@ -12188,13 +12988,14 @@ var MAX_REQUEST_BYTES6 = 128 * 1024;
 var MAX_PENDING_REQUESTS = 128;
 function startSoftwareHelper(options = {}) {
   const socketPath = options.socketPath ?? DEFAULT_SOFTWARE_HELPER_SOCKET;
-  if (existsSync16(socketPath))
+  if (existsSync17(socketPath))
     unlinkSync11(socketPath);
-  mkdirSync12(dirname8(socketPath), { recursive: true, mode: 488 });
+  mkdirSync13(dirname10(socketPath), { recursive: true, mode: 488 });
   const ensure = options.ensure ?? ensureSoftwareRequirements;
   const activate = options.activate ?? activateSupervisedService;
   const buildContainer = options.buildContainer ?? buildContainerImage;
   const activateTypedContainer = options.activateContainer ?? activateContainer;
+  const applyConnectivity = options.applyConnectivity ?? applyDeploymentConnectivity;
   let tail = Promise.resolve();
   let pending = 0;
   const server = createServer7((socket) => {
@@ -12251,6 +13052,12 @@ function startSoftwareHelper(options = {}) {
             throw new Error("container deployment root is not owned by this helper");
           const state = await activateTypedContainer(containerRequest);
           socket.end(`${JSON.stringify({ ok: true, state })}
+`);
+          return;
+        }
+        if (request.op === "apply-connectivity" && request.request) {
+          const result = await applyConnectivity(request.request);
+          socket.end(`${JSON.stringify({ ok: true, result })}
 `);
           return;
         }
@@ -12308,6 +13115,9 @@ function requestContainerBuild(request, socketPath = DEFAULT_SOFTWARE_HELPER_SOC
 function requestContainerActivation(request, socketPath = DEFAULT_SOFTWARE_HELPER_SOCKET, timeoutMs = 15 * 60000) {
   return requestContainer("activate-container", request, socketPath, timeoutMs);
 }
+function requestDeploymentConnectivity(request, socketPath = DEFAULT_SOFTWARE_HELPER_SOCKET, timeoutMs = 15 * 60000) {
+  return requestContainer("apply-connectivity", request, socketPath, timeoutMs);
+}
 function requestServiceActivation(request, socketPath = DEFAULT_SOFTWARE_HELPER_SOCKET, timeoutMs = 10 * 60000) {
   return new Promise((resolve6, reject) => {
     const socket = connect6(socketPath, () => socket.write(`${JSON.stringify({ op: "activate-service", request })}
@@ -12521,9 +13331,9 @@ var systemCommand = (argv2, stdin) => {
     stderr: result.stderr.toString()
   };
 };
-function resolveServiceUid(user, command2 = systemCommand) {
+function resolveServiceUid(user, command3 = systemCommand) {
   assertServiceUser(user);
-  const result = command2(["/usr/bin/id", "-u", user]);
+  const result = command3(["/usr/bin/id", "-u", user]);
   const uid = Number(result.stdout.trim());
   if (result.exitCode !== 0 || !/^\d+$/.test(result.stdout.trim())) {
     throw new Error(`Agent egress service account ${user} does not exist.`);
@@ -12548,14 +13358,14 @@ function assertResolvedStub(realpath = realpathSync4) {
     throw new Error("Agent egress requires the active systemd-resolved stub.");
   }
 }
-var listPolicy = (command2) => command2(["/usr/sbin/nft", "--numeric", "list", "table", "inet", AGENT_EGRESS_TABLE]);
-function verifyAgentEgressPolicy(uids, command2 = systemCommand, loopback) {
+var listPolicy = (command3) => command3(["/usr/sbin/nft", "--numeric", "list", "table", "inet", AGENT_EGRESS_TABLE]);
+function verifyAgentEgressPolicy(uids, command3 = systemCommand, loopback) {
   if (uids.length < 1)
     return false;
   for (const uid of uids)
     assertUid(uid);
   const uniqueUids = [...new Set(uids)].sort((left, right) => left - right);
-  const result = listPolicy(command2);
+  const result = listPolicy(command3);
   if (result.exitCode !== 0)
     return false;
   let loopbackComment = "";
@@ -12601,44 +13411,44 @@ function applyAgentEgressPolicy(options) {
   if (typeof getuid !== "function" || getuid() !== 0) {
     throw new Error("Agent egress policy must run as root.");
   }
-  const command2 = options.command ?? systemCommand;
+  const command3 = options.command ?? systemCommand;
   assertResolvedStub(options.realpath);
   if (options.users.length < 1)
     throw new Error("Agent egress policy needs at least one service user.");
-  const uids = [...new Set(options.users.map((user) => resolveServiceUid(user, command2)))];
+  const uids = [...new Set(options.users.map((user) => resolveServiceUid(user, command3)))];
   const loopback = options.loopback ? {
-    uid: resolveServiceUid(options.loopback.user, command2),
+    uid: resolveServiceUid(options.loopback.user, command3),
     tcpPorts: normalizeEgressTcpPorts(options.loopback.tcpPorts),
     publicTcpPorts: options.loopback.publicTcpPorts === undefined ? undefined : normalizeEgressTcpPorts(options.loopback.publicTcpPorts)
   } : undefined;
   if (loopback && !uids.includes(loopback.uid))
     uids.push(loopback.uid);
-  const current2 = listPolicy(command2);
-  const applied = command2(["/usr/sbin/nft", "--file", "-"], renderAgentEgressNft(uids, current2.exitCode === 0, loopback));
+  const current2 = listPolicy(command3);
+  const applied = command3(["/usr/sbin/nft", "--file", "-"], renderAgentEgressNft(uids, current2.exitCode === 0, loopback));
   if (applied.exitCode !== 0) {
     throw new Error(`Could not apply Agent egress policy: ${applied.stderr.trim() || "nft refused it"}`);
   }
-  if (!verifyAgentEgressPolicy(uids, command2, loopback)) {
+  if (!verifyAgentEgressPolicy(uids, command3, loopback)) {
     throw new Error("Agent egress policy did not verify after installation.");
   }
   return uids;
 }
 async function superviseAgentEgressPolicy(options) {
-  const command2 = options.command ?? systemCommand;
+  const command3 = options.command ?? systemCommand;
   const uids = applyAgentEgressPolicy({
     users: options.users,
     loopback: options.loopback,
-    command: command2,
+    command: command3,
     realpath: options.realpath,
     getuid: options.getuid
   });
   const loopback = options.loopback ? {
-    uid: resolveServiceUid(options.loopback.user, command2),
+    uid: resolveServiceUid(options.loopback.user, command3),
     tcpPorts: normalizeEgressTcpPorts(options.loopback.tcpPorts),
     publicTcpPorts: options.loopback.publicTcpPorts === undefined ? undefined : normalizeEgressTcpPorts(options.loopback.publicTcpPorts)
   } : undefined;
   (options.notifyReady ?? (() => {
-    const result = command2(["/usr/bin/systemd-notify", "--ready"]);
+    const result = command3(["/usr/bin/systemd-notify", "--ready"]);
     if (result.exitCode !== 0)
       throw new Error("Could not notify systemd that Agent egress is ready.");
   }))();
@@ -12649,7 +13459,7 @@ async function superviseAgentEgressPolicy(options) {
   }
   for (;; ) {
     await wait(intervalMs);
-    if (!verifyAgentEgressPolicy(uids, command2, loopback)) {
+    if (!verifyAgentEgressPolicy(uids, command3, loopback)) {
       throw new Error("Agent egress policy disappeared or changed; stopping the bound Agent.");
     }
   }
@@ -13260,7 +14070,7 @@ var AGENT_CREDENTIAL_POLICY = {
   "platform-compute": { vault: true, systemdFallback: true, hiddenInput: false },
   "tenant-compute": { vault: true, systemdFallback: true, hiddenInput: false }
 };
-var CREDENTIAL_NAME = /^[A-Z_][A-Z0-9_]*$/;
+var CREDENTIAL_NAME = /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/;
 var SCOPE_PART2 = /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/;
 function deploymentCredentialSchema(input) {
   if (!SCOPE_PART2.test(input.projectKey) || !SCOPE_PART2.test(input.environmentKey)) {
@@ -13302,17 +14112,17 @@ import {
   chmodSync as chmodSync15,
   chownSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   readFileSync as readFileSync14,
   readdirSync as readdirSync4,
   realpathSync as realpathSync5,
-  renameSync as renameSync10,
+  renameSync as renameSync11,
   rmSync as rmSync9,
-  statSync as statSync3,
+  statSync as statSync4,
   symlinkSync as symlinkSync4,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "fs";
 import { join as join10 } from "path";
 var boundedInteger2 = (name, value, minimum, maximum) => {
@@ -13372,7 +14182,7 @@ var replaceLink = (path2, target2) => {
     return;
   }
   symlinkSync4(target2, pending);
-  renameSync10(pending, path2);
+  renameSync11(pending, path2);
 };
 var secureRelease = (path2, uid, gid) => {
   const visit = (current2) => {
@@ -13395,7 +14205,7 @@ async function activatePlatformRelease(config, requestedRelease, options = {}) {
   if (!release.startsWith(`${releases}/`) || release === releases)
     throw new Error("release is outside configured releases directory");
   for (const required of ["forgezero.deploy.ts", ".fz/deploy.plan.json", "src/index.ts", "bun.lock"]) {
-    const metadata = statSync3(join10(release, required));
+    const metadata = statSync4(join10(release, required));
     if (!metadata.isFile() || metadata.size < 1)
       throw new Error(`release is incomplete: ${required}`);
   }
@@ -13403,9 +14213,9 @@ async function activatePlatformRelease(config, requestedRelease, options = {}) {
   const request = options.fetch ?? fetch;
   const sleep2 = options.sleep ?? Bun.sleep;
   const slots = join10(normalized.root, "slots");
-  mkdirSync13(slots, { recursive: true, mode: 493 });
+  mkdirSync14(slots, { recursive: true, mode: 493 });
   const slotFile = join10(normalized.root, ".forge-slot");
-  const previousSlot = existsSync17(slotFile) ? readFileSync14(slotFile, "utf8").trim() : undefined;
+  const previousSlot = existsSync18(slotFile) ? readFileSync14(slotFile, "utf8").trim() : undefined;
   const target2 = previousSlot === "blue" ? "green" : "blue";
   const port = target2 === "blue" ? normalized.bluePort : normalized.greenPort;
   const targetLink = join10(slots, target2);
@@ -13445,17 +14255,17 @@ async function activatePlatformRelease(config, requestedRelease, options = {}) {
   }
   const upstream = "/etc/nginx/conf.d/forgezero-upstream.conf";
   const backup = `${upstream}.forgezero-backup`;
-  if (existsSync17(upstream))
+  if (existsSync18(upstream))
     copyFileSync2(upstream, backup);
   else
     rmSync9(backup, { force: true });
-  writeFileSync13(upstream, `upstream forgezero { server 127.0.0.1:${port}; }
+  writeFileSync14(upstream, `upstream forgezero { server 127.0.0.1:${port}; }
 `, { mode: 420 });
   const test = await exec(["/usr/sbin/nginx", "-t"]);
   const reload = test.exitCode === 0 ? await exec(["/usr/sbin/nginx", "-s", "reload"]) : test;
   if (reload.exitCode !== 0) {
-    if (existsSync17(backup))
-      renameSync10(backup, upstream);
+    if (existsSync18(backup))
+      renameSync11(backup, upstream);
     else
       rmSync9(upstream, { force: true });
     await exec(["/usr/sbin/nginx", "-t"]);
@@ -13464,13 +14274,13 @@ async function activatePlatformRelease(config, requestedRelease, options = {}) {
     throw new Error("nginx refused the promoted upstream");
   }
   rmSync9(backup, { force: true });
-  writeFileSync13(slotFile, `${target2}
+  writeFileSync14(slotFile, `${target2}
 `, { mode: 420 });
   if (previousSlot && previousSlot !== target2) {
     await sleep2(normalized.drainDeadlineMs);
     await exec(["/usr/bin/systemctl", "stop", `forgezero@${previousSlot}.service`]);
   }
-  const old = readdirSync4(releases, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join10(releases, entry.name)).sort((left, right) => statSync3(right).mtimeMs - statSync3(left).mtimeMs).slice(normalized.keepReleases);
+  const old = readdirSync4(releases, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join10(releases, entry.name)).sort((left, right) => statSync4(right).mtimeMs - statSync4(left).mtimeMs).slice(normalized.keepReleases);
   for (const path2 of old)
     if (path2 !== release)
       rmSync9(path2, { recursive: true, force: true });
@@ -13478,7 +14288,7 @@ async function activatePlatformRelease(config, requestedRelease, options = {}) {
 }
 
 // src/recovery-host.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
 import { hostname } from "os";
 import { join as join11 } from "path";
 var execute2 = async (argv2) => {
@@ -13486,7 +14296,7 @@ var execute2 = async (argv2) => {
   const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
   return { stdout, stderr, exitCode };
 };
-var checked7 = async (run2, argv2, expected = 0) => {
+var checked8 = async (run2, argv2, expected = 0) => {
   const result = await run2(argv2);
   if (result.exitCode !== expected)
     throw new Error(`${argv2[0]} failed (${result.exitCode})`);
@@ -13504,7 +14314,7 @@ var exactState = (path2, expected) => {
     throw new Error(`state mismatch: ${expected}`);
 };
 var nonEmpty = (path2) => {
-  if (!existsSync18(path2) || !statSync4(path2).isFile() || statSync4(path2).size < 1)
+  if (!existsSync19(path2) || !statSync5(path2).isFile() || statSync5(path2).size < 1)
     throw new Error(`required file missing: ${path2}`);
 };
 var option = (args, name) => {
@@ -13548,29 +14358,29 @@ async function runRecoveryHost(args, run2 = execute2) {
     const slot = activeSlot();
     nonEmpty(join11("/opt/forgezero/slots", slot, "src/server/maintenance/restore-backup.ts"));
     nonEmpty(join11("/opt/forgezero/slots", slot, "src/server/maintenance/verify-recovery-cluster.ts"));
-    await checked7(run2, ["/usr/bin/test", "-x", "/usr/local/bin/fz"]);
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero-db.service"], hasDatabase ? 0 : 3);
+    await checked8(run2, ["/usr/bin/test", "-x", "/usr/local/bin/fz"]);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero-db.service"], hasDatabase ? 0 : 3);
     if (args.includes("--require-stopped")) {
-      await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@blue.service"], 3);
-      await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@green.service"], 3);
+      await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@blue.service"], 3);
+      await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@green.service"], 3);
     }
     return;
   }
   if (action === "fence") {
-    await checked7(run2, ["/usr/bin/systemctl", "stop", "forgezero@blue.service", "forgezero@green.service"]);
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@blue.service"], 3);
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@green.service"], 3);
+    await checked8(run2, ["/usr/bin/systemctl", "stop", "forgezero@blue.service", "forgezero@green.service"]);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@blue.service"], 3);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero@green.service"], 3);
     const role = option(args, "db-role");
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero-db.service"], role === "none" ? 3 : 0);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", "forgezero-db.service"], role === "none" ? 3 : 0);
     return;
   }
   if (action === "start-active") {
     const slot = activeSlot();
     const inactive = slot === "blue" ? "green" : "blue";
-    await checked7(run2, ["/usr/bin/systemctl", "stop", `forgezero@${inactive}.service`]);
-    await checked7(run2, ["/usr/bin/systemctl", "start", `forgezero@${slot}.service`]);
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", `forgezero@${slot}.service`]);
-    await checked7(run2, ["/usr/bin/systemctl", "is-active", "--quiet", `forgezero@${inactive}.service`], 3);
+    await checked8(run2, ["/usr/bin/systemctl", "stop", `forgezero@${inactive}.service`]);
+    await checked8(run2, ["/usr/bin/systemctl", "start", `forgezero@${slot}.service`]);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", `forgezero@${slot}.service`]);
+    await checked8(run2, ["/usr/bin/systemctl", "is-active", "--quiet", `forgezero@${inactive}.service`], 3);
     return;
   }
   if (action === "maintenance") {
@@ -13593,7 +14403,7 @@ async function runRecoveryHost(args, run2 = execute2) {
         "--property=LoadCredentialEncrypted=backup-recovery-root:/etc/forgezero/creds/backup-recovery-root.cred"
       ] : []
     ];
-    await checked7(run2, ["/usr/bin/systemd-run", "--quiet", "--wait", "--pipe", "--collect", `--unit=${unit2(option(args, "unit"))}`, ...properties, "/usr/local/bin/fz", ...fzArgs]);
+    await checked8(run2, ["/usr/bin/systemd-run", "--quiet", "--wait", "--pipe", "--collect", `--unit=${unit2(option(args, "unit"))}`, ...properties, "/usr/local/bin/fz", ...fzArgs]);
     return;
   }
   throw new Error("unknown recovery-host action");
@@ -13605,15 +14415,15 @@ import { lstatSync as lstatSync6 } from "fs";
 // src/bootstrap.ts
 import {
   chmodSync as chmodSync17,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   lstatSync as lstatSync5,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   readFileSync as readFileSync17,
-  renameSync as renameSync12,
+  renameSync as renameSync13,
   rmSync as rmSync11,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/provision.ts
@@ -14546,17 +15356,17 @@ import { randomBytes as randomBytes6 } from "crypto";
 import {
   chmodSync as chmodSync16,
   copyFileSync as copyFileSync3,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   lstatSync as lstatSync4,
-  mkdirSync as mkdirSync14,
+  mkdirSync as mkdirSync15,
   readFileSync as readFileSync16,
   realpathSync as realpathSync6,
-  renameSync as renameSync11,
+  renameSync as renameSync12,
   rmSync as rmSync10,
   symlinkSync as symlinkSync5,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname11 } from "path";
 async function readCapabilities(run2) {
   const answers = {};
   const checks = Object.entries(CAPABILITY_CHECKS);
@@ -14577,10 +15387,8 @@ var fixed = async (argv2, stdin) => {
     stderr: "pipe",
     env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", LANG: "C", LC_ALL: "C", DEBIAN_FRONTEND: "noninteractive" }
   });
-  if (stdin !== undefined && child.stdin && typeof child.stdin !== "number") {
-    child.stdin.write(stdin);
-    child.stdin.end();
-  }
+  if (stdin !== undefined && child.stdin && typeof child.stdin !== "number")
+    await writeAndCloseProcessInput(child.stdin, stdin);
   const [stdout, stderr, exitCode] = await Promise.all([
     new Response(child.stdout).text(),
     new Response(child.stderr).text(),
@@ -14591,10 +15399,10 @@ var fixed = async (argv2, stdin) => {
 var runProvisionOperation = async (operation) => {
   if (operation.kind === "commands") {
     let output = "";
-    for (const command2 of operation.commands) {
-      const result = await fixed(command2.argv);
+    for (const command3 of operation.commands) {
+      const result = await fixed(command3.argv);
       output += result.stdout;
-      if (!(command2.acceptedExitCodes ?? [0]).includes(result.exitCode))
+      if (!(command3.acceptedExitCodes ?? [0]).includes(result.exitCode))
         return { stdout: output, exitCode: result.exitCode };
     }
     return { stdout: output, exitCode: 0 };
@@ -14615,19 +15423,19 @@ var runProvisionOperation = async (operation) => {
   }
   if (operation.kind === "install-runtime") {
     const release = `/opt/forgezero/agent/versions/${operation.version}`;
-    mkdirSync14(`${release}/dist`, { recursive: true, mode: 493 });
-    mkdirSync14(dirname9(operation.binary), { recursive: true, mode: 493 });
+    mkdirSync15(`${release}/dist`, { recursive: true, mode: 493 });
+    mkdirSync15(dirname11(operation.binary), { recursive: true, mode: 493 });
     copyFileSync3(operation.source, `${release}/dist/fz-agent.js`);
     chmodSync16(`${release}/dist/fz-agent.js`, 493);
-    const gitSshSource = `${dirname9(operation.source)}/fz-git-ssh.js`;
-    if (!existsSync19(gitSshSource))
+    const gitSshSource = `${dirname11(operation.source)}/fz-git-ssh.js`;
+    if (!existsSync20(gitSshSource))
       return { stdout: "packaged fz-git-ssh.js is missing", exitCode: 1 };
     copyFileSync3(gitSshSource, `${release}/dist/fz-git-ssh.js`);
     chmodSync16(`${release}/dist/fz-git-ssh.js`, 493);
     const pending = "/opt/forgezero/agent/current.next";
     rmSync10(pending, { force: true });
     symlinkSync5(`versions/${operation.version}`, pending);
-    renameSync11(pending, "/opt/forgezero/agent/current");
+    renameSync12(pending, "/opt/forgezero/agent/current");
     rmSync10(operation.binary, { force: true });
     symlinkSync5("/opt/forgezero/agent/current/dist/fz-agent.js", operation.binary);
     const gitSshBinary = "/usr/local/lib/forgezero/agent/fz-git-ssh";
@@ -14636,7 +15444,7 @@ var runProvisionOperation = async (operation) => {
     return { stdout: "", exitCode: 0 };
   }
   if (operation.kind === "ensure-seed") {
-    if (existsSync19(operation.credential) && lstatSync4(operation.credential).size > 0)
+    if (existsSync20(operation.credential) && lstatSync4(operation.credential).size > 0)
       return { stdout: "", exitCode: 0 };
     const seed = randomBytes6(32).toString("base64url");
     const result = await fixed(["/usr/bin/systemd-creds", "encrypt", "--name=agent-seed", "-", operation.credential], seed);
@@ -14648,7 +15456,7 @@ var runProvisionOperation = async (operation) => {
     const key = "/run/forgezero-git-deploy-key";
     const publicKey = `${key}.pub`;
     try {
-      if (!existsSync19(operation.credential) || lstatSync4(operation.credential).size < 1) {
+      if (!existsSync20(operation.credential) || lstatSync4(operation.credential).size < 1) {
         rmSync10(key, { force: true });
         rmSync10(publicKey, { force: true });
         let result = await fixed(["/usr/bin/ssh-keygen", "-q", "-t", "ed25519", "-N", "", "-C", "forgezero-compute", "-f", key]);
@@ -14659,8 +15467,8 @@ var runProvisionOperation = async (operation) => {
           return result;
         chmodSync16(operation.credential, 256);
       }
-      if (!existsSync19(operation.publicKey) || lstatSync4(operation.publicKey).size < 1) {
-        if (!existsSync19(key)) {
+      if (!existsSync20(operation.publicKey) || lstatSync4(operation.publicKey).size < 1) {
+        if (!existsSync20(key)) {
           const decrypted = await fixed(["/usr/bin/systemd-creds", "decrypt", "--name=git-deploy-key", operation.credential, key]);
           if (decrypted.exitCode !== 0)
             return decrypted;
@@ -14668,7 +15476,7 @@ var runProvisionOperation = async (operation) => {
         const derived = await fixed(["/usr/bin/ssh-keygen", "-y", "-f", key]);
         if (derived.exitCode !== 0)
           return derived;
-        writeFileSync14(operation.publicKey, `${derived.stdout.trim()} forgezero-compute
+        writeFileSync15(operation.publicKey, `${derived.stdout.trim()} forgezero-compute
 `, { mode: 292 });
       }
       return { stdout: "", exitCode: 0 };
@@ -14681,12 +15489,12 @@ var runProvisionOperation = async (operation) => {
     const key = "/run/forgezero-bootstrap-ssh-key";
     const generatedPublicKey = `${key}.pub`;
     try {
-      if (!existsSync19(operation.credential) || lstatSync4(operation.credential).size < 1) {
+      if (!existsSync20(operation.credential) || lstatSync4(operation.credential).size < 1) {
         rmSync10(key, { force: true });
         rmSync10(generatedPublicKey, { force: true });
         let result;
         if (operation.source) {
-          const source = existsSync19(operation.source) ? lstatSync4(operation.source) : undefined;
+          const source = existsSync20(operation.source) ? lstatSync4(operation.source) : undefined;
           if (!source?.isFile() || source.isSymbolicLink() || source.uid !== 0 || source.nlink !== 1 || (source.mode & 63) !== 0 || source.size < 32 || source.size > 16 * 1024) {
             return { stdout: "bootstrap SSH private-key source is missing or unsafe", exitCode: 1 };
           }
@@ -14706,8 +15514,8 @@ var runProvisionOperation = async (operation) => {
           return result;
         chmodSync16(operation.credential, 256);
       }
-      if (!existsSync19(operation.publicKey) || lstatSync4(operation.publicKey).size < 1) {
-        if (!existsSync19(key)) {
+      if (!existsSync20(operation.publicKey) || lstatSync4(operation.publicKey).size < 1) {
+        if (!existsSync20(key)) {
           const decrypted = await fixed(["/usr/bin/systemd-creds", "decrypt", "--name=bootstrap-ssh-key", operation.credential, key]);
           if (decrypted.exitCode !== 0)
             return decrypted;
@@ -14717,8 +15525,8 @@ var runProvisionOperation = async (operation) => {
         if (derived.exitCode !== 0 || !/^ssh-ed25519 [A-Za-z0-9+/]+={0,3}\s*$/.test(derived.stdout)) {
           return { stdout: "bootstrap SSH public key derivation failed", exitCode: 1 };
         }
-        mkdirSync14(dirname9(operation.publicKey), { recursive: true, mode: 493 });
-        writeFileSync14(operation.publicKey, `${derived.stdout.trim()} forgezero-bootstrap-runner
+        mkdirSync15(dirname11(operation.publicKey), { recursive: true, mode: 493 });
+        writeFileSync15(operation.publicKey, `${derived.stdout.trim()} forgezero-bootstrap-runner
 `, { mode: 292 });
         chmodSync16(operation.publicKey, 292);
       }
@@ -14731,9 +15539,9 @@ var runProvisionOperation = async (operation) => {
     }
   }
   if (operation.kind === "ensure-enrolment") {
-    if (existsSync19(operation.state) && lstatSync4(operation.state).size > 0 || existsSync19(operation.credential) && lstatSync4(operation.credential).size > 0)
+    if (existsSync20(operation.state) && lstatSync4(operation.state).size > 0 || existsSync20(operation.credential) && lstatSync4(operation.credential).size > 0)
       return { stdout: "", exitCode: 0 };
-    if (!existsSync19(operation.source))
+    if (!existsSync20(operation.source))
       return { stdout: "enrolment source is missing", exitCode: 1 };
     const result = await fixed(["/usr/bin/systemd-creds", "encrypt", "--name=enrol-token", operation.source, operation.credential]);
     if (result.exitCode === 0) {
@@ -14753,7 +15561,7 @@ var runProvisionOperation = async (operation) => {
     return { stdout: `socket did not become ready: ${operation.path}`, exitCode: 1 };
   }
   if (operation.kind === "verify-file")
-    return existsSync19(operation.path) && lstatSync4(operation.path).size > 0 ? { stdout: "", exitCode: 0 } : { stdout: "required file is empty", exitCode: 1 };
+    return existsSync20(operation.path) && lstatSync4(operation.path).size > 0 ? { stdout: "", exitCode: 0 } : { stdout: "required file is empty", exitCode: 1 };
   if (operation.kind === "verify-egress") {
     const active = await fixed(["/usr/bin/systemctl", "is-active", "forgezero-agent-egress.service"]);
     if (active.exitCode !== 0)
@@ -14781,11 +15589,11 @@ var runProvisionOperation = async (operation) => {
     const response = await fetch("https://pkg.cloudflareclient.com/pubkey.gpg", { signal: AbortSignal.timeout(30000) });
     if (!response.ok)
       return { stdout: `WARP key HTTP ${response.status}`, exitCode: 1 };
-    mkdirSync14("/usr/share/keyrings", { recursive: true, mode: 493 });
-    mkdirSync14("/etc/apt/sources.list.d", { recursive: true, mode: 493 });
-    mkdirSync14("/etc/systemd/system/warp-svc.service.d", { recursive: true, mode: 493 });
+    mkdirSync15("/usr/share/keyrings", { recursive: true, mode: 493 });
+    mkdirSync15("/etc/apt/sources.list.d", { recursive: true, mode: 493 });
+    mkdirSync15("/etc/systemd/system/warp-svc.service.d", { recursive: true, mode: 493 });
     const key = "/run/cloudflare-warp-key.gpg";
-    writeFileSync14(key, new Uint8Array(await response.arrayBuffer()), { mode: 384 });
+    writeFileSync15(key, new Uint8Array(await response.arrayBuffer()), { mode: 384 });
     let result = await fixed(["/usr/bin/gpg", "--batch", "--yes", "--dearmor", "-o", "/usr/share/keyrings/cloudflare-warp-archive-keyring.gpg", key]);
     rmSync10(key, { force: true });
     if (result.exitCode !== 0)
@@ -14793,7 +15601,7 @@ var runProvisionOperation = async (operation) => {
     const codename = os.match(/^VERSION_CODENAME=(.+)$/m)?.[1]?.replace(/^"|"$/g, "");
     if (!codename)
       return { stdout: "Ubuntu codename missing", exitCode: 1 };
-    writeFileSync14("/etc/apt/sources.list.d/cloudflare-client.list", `deb [signed-by=/usr/share/keyrings/cloudflare-warp-archive-keyring.gpg] https://pkg.cloudflareclient.com/ ${codename} main
+    writeFileSync15("/etc/apt/sources.list.d/cloudflare-client.list", `deb [signed-by=/usr/share/keyrings/cloudflare-warp-archive-keyring.gpg] https://pkg.cloudflareclient.com/ ${codename} main
 `, { mode: 420 });
     result = await fixed(["/usr/bin/apt-get", "update", "-qq"]);
     return result.exitCode === 0 ? fixed(["/usr/bin/apt-get", "install", "-y", "cloudflare-warp"]) : result;
@@ -15095,8 +15903,7 @@ function localBootstrapHost() {
   const execute3 = async (argv2, options = {}) => {
     const child = Bun.spawn([...argv2], { stdin: options.stdin === undefined ? "ignore" : "pipe", stdout: "pipe", stderr: "pipe" });
     if (options.stdin !== undefined && child.stdin && typeof child.stdin !== "number") {
-      child.stdin.write(options.stdin);
-      child.stdin.end();
+      await writeAndCloseProcessInput(child.stdin, options.stdin);
     }
     const [stdout, stderr, exitCode] = await Promise.all([
       new Response(child.stdout).text(),
@@ -15107,16 +15914,16 @@ function localBootstrapHost() {
   };
   return {
     uid: () => process.getuid?.() ?? -1,
-    exists: existsSync20,
+    exists: existsSync21,
     read: (path2) => readFileSync17(path2, "utf8"),
     write(path2, content, mode) {
-      mkdirSync15(dirname10(path2), { recursive: true, mode: 493 });
+      mkdirSync16(dirname12(path2), { recursive: true, mode: 493 });
       const temporary = `${path2}.next.${process.pid}`;
-      writeFileSync15(temporary, content, { mode });
+      writeFileSync16(temporary, content, { mode });
       chmodSync17(temporary, mode);
-      renameSync12(temporary, path2);
+      renameSync13(temporary, path2);
     },
-    mkdir: (path2, mode) => mkdirSync15(path2, { recursive: true, mode }),
+    mkdir: (path2, mode) => mkdirSync16(path2, { recursive: true, mode }),
     remove: (path2) => rmSync11(path2, { force: true }),
     inspect(path2) {
       const value = lstatSync5(path2);
@@ -15140,9 +15947,9 @@ function localBootstrapHost() {
     },
     async installAgent(config, phase) {
       const capabilities = await readCapabilities(localRunner);
-      const hasBinding = existsSync20("/var/lib/forgezero/enrolment.json");
-      const hasEnrolCredential = existsSync20(ENROL_CREDENTIAL);
-      const initialBundle = config.kind === "platform" && !existsSync20(BOOTSTRAP_RELEASE_EVIDENCE) ? {
+      const hasBinding = existsSync21("/var/lib/forgezero/enrolment.json");
+      const hasEnrolCredential = existsSync21(ENROL_CREDENTIAL);
+      const initialBundle = config.kind === "platform" && !existsSync21(BOOTSTRAP_RELEASE_EVIDENCE) ? {
         path: config.bootstrapBundle.bundleFile,
         manifestPath: config.bootstrapBundle.manifestFile,
         manifest: parseBootstrapBundleManifest(JSON.parse(readFileSync17(config.bootstrapBundle.manifestFile, "utf8")))
@@ -15158,8 +15965,8 @@ function localBootstrapHost() {
           databaseHealthUrl: `http://${config.database.address}:8529/_api/version`,
           databasePorts: [8529]
         };
-        mkdirSync15(dirname10(LIFECYCLE_PROFILE), { recursive: true, mode: 493 });
-        writeFileSync15(LIFECYCLE_PROFILE, `${JSON.stringify(lifecycle, null, 2)}
+        mkdirSync16(dirname12(LIFECYCLE_PROFILE), { recursive: true, mode: 493 });
+        writeFileSync16(LIFECYCLE_PROFILE, `${JSON.stringify(lifecycle, null, 2)}
 `, { mode: 256 });
       }
       const plan = planBootstrapAgentInstall(config, phase, {
@@ -15169,8 +15976,8 @@ function localBootstrapHost() {
         initialBundle
       });
       for (const unit3 of [{ path: plan.unitPath, unit: plan.unit }, ...plan.auxiliaryUnits]) {
-        mkdirSync15(dirname10(unit3.path), { recursive: true, mode: 493 });
-        writeFileSync15(unit3.path, unit3.unit, { mode: 420 });
+        mkdirSync16(dirname12(unit3.path), { recursive: true, mode: 493 });
+        writeFileSync16(unit3.path, unit3.unit, { mode: 420 });
       }
       await applyPlan(plan, localRunner);
       return plan;
@@ -15222,10 +16029,10 @@ async function verifyPlatformFleetHost(expectedVersion, runtime = localRuntime()
 }
 
 // src/community-rehearsal-host.ts
-import { createHash as createHash11 } from "crypto";
-import { lstatSync as lstatSync7, mkdirSync as mkdirSync16, readFileSync as readFileSync18, rmSync as rmSync12, symlinkSync as symlinkSync6, unlinkSync as unlinkSync12, writeFileSync as writeFileSync16 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { lstatSync as lstatSync7, mkdirSync as mkdirSync17, readFileSync as readFileSync18, rmSync as rmSync12, symlinkSync as symlinkSync6, unlinkSync as unlinkSync12, writeFileSync as writeFileSync17 } from "fs";
 import { isIP as isIP5 } from "net";
-import { dirname as dirname11 } from "path";
+import { dirname as dirname13 } from "path";
 var COMMUNITY_REHEARSAL_VERSION = "3.11.14";
 var COMMUNITY_REHEARSAL_ROOT = "/opt/forgezero-rehearsals/community-cluster-api";
 var COMMUNITY_DATABASE_ROOT = "/var/lib/forgezero-rehearsal-cluster";
@@ -15427,10 +16234,8 @@ function planCommunityRehearsalCleanup() {
 }
 async function exec(argv2, stdin) {
   const child = Bun.spawn([...argv2], { stdin: stdin === undefined ? "ignore" : "pipe", stdout: "pipe", stderr: "pipe" });
-  if (stdin !== undefined && child.stdin && typeof child.stdin !== "number") {
-    child.stdin.write(stdin);
-    child.stdin.end();
-  }
+  if (stdin !== undefined && child.stdin && typeof child.stdin !== "number")
+    await writeAndCloseProcessInput(child.stdin, stdin);
   const [stdout, stderr, exitCode] = await Promise.all([
     new Response(child.stdout).text(),
     new Response(child.stderr).text(),
@@ -15443,8 +16248,8 @@ async function applyOperations(operations) {
     if (operation.kind === "remove-tree")
       rmSync12(operation.path, { recursive: true, force: true });
     else if (operation.kind === "write") {
-      mkdirSync16(dirname11(operation.path), { recursive: true });
-      writeFileSync16(operation.path, operation.content, { mode: operation.mode });
+      mkdirSync17(dirname13(operation.path), { recursive: true });
+      writeFileSync17(operation.path, operation.content, { mode: operation.mode });
     } else if (operation.kind === "unlink") {
       try {
         unlinkSync12(operation.path);
@@ -15496,7 +16301,7 @@ async function runCommunityRehearsalHost(request) {
   }
   if (request.action === "prepare") {
     const metadata = lstatSync7(request.archivePath);
-    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size < 1 || metadata.size > 64 * 1024 * 1024 || createHash11("sha256").update(readFileSync18(request.archivePath)).digest("hex") !== request.archiveSha256) {
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size < 1 || metadata.size > 64 * 1024 * 1024 || createHash12("sha256").update(readFileSync18(request.archivePath)).digest("hex") !== request.archiveSha256) {
       throw new Error("community rehearsal archive is not the declared bounded release");
     }
     await ensureCommunityRehearsalArango();
@@ -15590,23 +16395,23 @@ async function runSupervisedApp(path2) {
 }
 
 // src/index.ts
-function agentCommandArgs(args, command2) {
-  const index = args.indexOf(command2);
+function agentCommandArgs(args, command3) {
+  const index = args.indexOf(command3);
   if (index < 0)
-    throw new Error(`missing Agent command ${command2}`);
+    throw new Error(`missing Agent command ${command3}`);
   return args.slice(index + 1);
 }
 function loadOrCreateSeed(path2) {
-  if (existsSync21(path2)) {
+  if (existsSync22(path2)) {
     const seed2 = new Uint8Array(Buffer.from(readFileSync20(path2, "utf8").trim(), "base64url"));
     if (seed2.length < 32) {
       throw new Error(`agent: the seed at ${path2} is too short to derive a key from.`);
     }
     return seed2;
   }
-  mkdirSync17(dirname12(path2), { recursive: true });
+  mkdirSync18(dirname14(path2), { recursive: true });
   const seed = new Uint8Array(randomBytes7(32));
-  writeFileSync17(path2, Buffer.from(seed).toString("base64url"), { mode: 384 });
+  writeFileSync18(path2, Buffer.from(seed).toString("base64url"), { mode: 384 });
   chmodSync18(path2, 384);
   return seed;
 }
@@ -15636,7 +16441,7 @@ function loadSeedCredential(name = DEFAULT_SEED_CREDENTIAL, directory = process.
   if (!directory)
     throw new Error("agent: CREDENTIALS_DIRECTORY is missing; systemd did not load the node identity.");
   const path2 = `${directory}/${name}`;
-  if (!existsSync21(path2))
+  if (!existsSync22(path2))
     throw new Error(`agent: the systemd credential ${name} is missing at ${path2}.`);
   const seed = new Uint8Array(Buffer.from(readFileSync20(path2, "utf8").trim(), "base64url"));
   if (seed.length < 32)
@@ -15658,7 +16463,7 @@ function createSystemdDeploymentSecrets(names, directory = process.env.CREDENTIA
   if (allowed.size === 0)
     return;
   for (const name of allowed) {
-    if (!/^[A-Z_][A-Z0-9_]*$/.test(name))
+    if (!/^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/.test(name))
       throw new Error(`agent: invalid pipeline credential name ${name}.`);
   }
   return {
@@ -15764,8 +16569,8 @@ if (import.meta.main) {
     console.log(VERSION2);
     process.exit(0);
   }
-  const command2 = args.find((arg) => !arg.startsWith("-"));
-  if (command2 === "platform-activate") {
+  const command3 = args.find((arg) => !arg.startsWith("-"));
+  if (command3 === "platform-activate") {
     if (process.getuid?.() !== 0)
       throw new Error("platform-activate must run as root");
     const configPath = args.find((arg) => arg.startsWith("--config="))?.slice("--config=".length);
@@ -15778,14 +16583,14 @@ if (import.meta.main) {
     console.log(`promoted ${result.release} on ${result.slot}`);
     process.exit(0);
   }
-  if (command2 === "recovery-host") {
+  if (command3 === "recovery-host") {
     if (process.getuid?.() !== 0)
       throw new Error("recovery-host must run as root");
     const commandIndex = args.indexOf("recovery-host");
     await runRecoveryHost(args.slice(commandIndex + 1));
     process.exit(0);
   }
-  if (command2 === "pipeline-todo") {
+  if (command3 === "pipeline-todo") {
     const index = args.indexOf("pipeline-todo");
     const message = args[index + 1];
     if (!message || args.length !== index + 2 || message.length > 2000 || /[\r\n\0]/.test(message)) {
@@ -15794,7 +16599,7 @@ if (import.meta.main) {
     console.error(message);
     process.exit(78);
   }
-  if (command2 === "project-release-check") {
+  if (command3 === "project-release-check") {
     if (args.length !== 1)
       throw new Error("project-release-check accepts no coordinates");
     for (const relative of ["src/index.ts", "bun.lock", "src/generated/shared/contract-manifest.json"]) {
@@ -15813,7 +16618,7 @@ if (import.meta.main) {
     process.exit(0);
   }
   const allowFileSeed = process.env.FZ_ALLOW_FILE_SEED === "1";
-  if (command2 === "identity") {
+  if (command3 === "identity") {
     const seed = configuredAgentSeed({
       credential: process.env.FZ_SEED_CREDENTIAL,
       path: process.env.FZ_SEED_PATH,
@@ -15827,7 +16632,7 @@ if (import.meta.main) {
     }, null, 2));
     process.exit(0);
   }
-  if (command2 === "enrol") {
+  if (command3 === "enrol") {
     if (!process.env.FZ_API)
       throw new Error("agent enrolment requires FZ_API");
     if (!process.env.FZ_ENROL_TOKEN_CREDENTIAL) {
@@ -15856,7 +16661,7 @@ if (import.meta.main) {
     console.log(`[agent] enrolled ${binding2.computeReference} in project ${binding2.projectKey}/${binding2.environmentKey}`);
     process.exit(0);
   }
-  if (command2 === "egress-policy" || command2 === "egress-policy-check") {
+  if (command3 === "egress-policy" || command3 === "egress-policy-check") {
     const users = args.filter((arg) => arg.startsWith("--user=")).map((arg) => arg.slice("--user=".length));
     if (users.length < 1)
       throw new Error("egress-policy requires --user=<service-user>");
@@ -15875,7 +16680,7 @@ if (import.meta.main) {
       tcpPorts: loopbackTcpPorts,
       publicTcpPorts: publicTcpPorts.length > 0 ? publicTcpPorts : undefined
     } : undefined;
-    if (command2 === "egress-policy-check") {
+    if (command3 === "egress-policy-check") {
       const uids = users.map((user) => resolveServiceUid(user));
       const grant = loopback ? {
         uid: resolveServiceUid(loopback.user),
@@ -15888,7 +16693,7 @@ if (import.meta.main) {
     }
     await superviseAgentEgressPolicy({ users, loopback });
   }
-  if (command2 === "metal-helper") {
+  if (command3 === "metal-helper") {
     const profilePath = args.find((arg) => arg.startsWith("--profile="))?.slice("--profile=".length);
     if (!profilePath)
       throw new Error("metal-helper requires --profile=/absolute/path.json");
@@ -15910,7 +16715,7 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop());
     await new Promise(() => {});
   }
-  if (command2 === "lifecycle-helper") {
+  if (command3 === "lifecycle-helper") {
     const profilePath = args.find((arg) => arg.startsWith("--profile="))?.slice("--profile=".length);
     if (!profilePath?.startsWith("/"))
       throw new Error("lifecycle-helper requires --profile=/absolute/path.json");
@@ -15934,7 +16739,7 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop());
     await new Promise(() => {});
   }
-  if (command2 === "warp-config") {
+  if (command3 === "warp-config") {
     const organization = args.find((arg) => arg.startsWith("--organization="))?.slice("--organization=".length);
     if (!organization)
       throw new Error("warp-config requires --organization=<team-name>");
@@ -15952,7 +16757,7 @@ if (import.meta.main) {
     console.log("[warp-config] enrollment materialized in tmpfs");
     process.exit(0);
   }
-  if (command2 === "mesh-config") {
+  if (command3 === "mesh-config") {
     if (typeof process.getuid !== "function" || process.getuid() !== 0)
       throw new Error("mesh-config must run as root");
     const token = readMeshConnectorCredential();
@@ -15975,7 +16780,7 @@ if (import.meta.main) {
     console.log("[mesh-config] Cloudflare Mesh connector is connected");
     process.exit(0);
   }
-  if (command2 === "update-helper") {
+  if (command3 === "update-helper") {
     if (typeof process.getuid !== "function" || process.getuid() !== 0) {
       throw new Error("update-helper must run as root");
     }
@@ -15994,7 +16799,7 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop());
     await new Promise(() => {});
   }
-  if (command2 === "software-helper") {
+  if (command3 === "software-helper") {
     if (typeof process.getuid !== "function" || process.getuid() !== 0) {
       throw new Error("software-helper must run as root");
     }
@@ -16016,13 +16821,13 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop());
     await new Promise(() => {});
   }
-  if (command2 === "supervised-app") {
+  if (command3 === "supervised-app") {
     const config = args.find((arg) => arg.startsWith("--config="))?.slice("--config=".length);
     if (!config)
       throw new Error("supervised-app requires --config=<absolute-path>");
     process.exit(await runSupervisedApp(config));
   }
-  if (command2 === "software-ensure") {
+  if (command3 === "software-ensure") {
     const requirements = args.filter((arg) => arg.startsWith("--require=")).map((arg) => {
       const coordinate = arg.slice("--require=".length);
       const separator = coordinate.indexOf("@");
@@ -16038,7 +16843,7 @@ if (import.meta.main) {
     console.log(JSON.stringify({ ok: true, results }));
     process.exit(0);
   }
-  if (command2 === "metal-isolation") {
+  if (command3 === "metal-isolation") {
     const profilePath = args.find((arg) => arg.startsWith("--profile="))?.slice("--profile=".length);
     if (!profilePath)
       throw new Error("metal-isolation requires --profile=/absolute/path.json");
@@ -16047,7 +16852,7 @@ if (import.meta.main) {
     console.log("[metal-isolation] host and guest cgroup boundaries active");
     process.exit(0);
   }
-  if (command2 === "deploy-runner") {
+  if (command3 === "deploy-runner") {
     const root2 = args.find((arg) => arg.startsWith("--root="))?.slice("--root=".length);
     const home = args.find((arg) => arg.startsWith("--home="))?.slice("--home=".length);
     if (!root2 || !home)
@@ -16077,7 +16882,7 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop());
     await new Promise(() => {});
   }
-  if (command2 === "metal-apply") {
+  if (command3 === "metal-apply") {
     const claimArg = args.find((arg) => arg.startsWith("--claim="))?.slice("--claim=".length);
     if (!claimArg)
       throw new Error("metal-apply requires --claim=- or --claim=/absolute/path.json");
@@ -16098,8 +16903,8 @@ if (import.meta.main) {
     console.log(JSON.stringify({ ok: true, computeKey: claim.computeKey, ...result }));
     process.exit(0);
   }
-  if (command2 === "platform-fleet-verify") {
-    const commandArgs = agentCommandArgs(args, command2);
+  if (command3 === "platform-fleet-verify") {
+    const commandArgs = agentCommandArgs(args, command3);
     const expectedVersion = commandArgs.find((arg) => arg.startsWith("--expected-version="))?.slice("--expected-version=".length);
     if (!expectedVersion || commandArgs.length !== 1) {
       throw new Error("platform-fleet-verify requires exactly --expected-version=<semver>");
@@ -16107,8 +16912,8 @@ if (import.meta.main) {
     console.log(JSON.stringify(await verifyPlatformFleetHost(expectedVersion)));
     process.exit(0);
   }
-  if (command2 === "community-rehearsal") {
-    const commandArgs = agentCommandArgs(args, command2);
+  if (command3 === "community-rehearsal") {
+    const commandArgs = agentCommandArgs(args, command3);
     if (commandArgs.length !== 1 || commandArgs[0] !== "--request=-") {
       throw new Error("community-rehearsal requires exactly --request=-");
     }
@@ -16119,7 +16924,7 @@ if (import.meta.main) {
     console.log(JSON.stringify(await runCommunityRehearsalHost(request)));
     process.exit(0);
   }
-  if (command2 === "metal-admission-proof") {
+  if (command3 === "metal-admission-proof") {
     if (args.length !== 1 || args[0] !== "--request=-") {
       throw new Error("metal-admission-proof requires exactly --request=-");
     }
@@ -16133,17 +16938,17 @@ if (import.meta.main) {
     const seed = configuredAgentSeed({ credential: process.env.FZ_SEED_CREDENTIAL, allowFileSeed: false });
     const keys2 = deriveKeysFromSeed(seed);
     seed.fill(0);
-    const filesystem = statfsSync2("/var/lib/forgezero");
+    const filesystem = statfsSync3("/var/lib/forgezero");
     const body = {
       ...request,
       publicKeys: { ed25519: keys2.ed25519.publicKey, mlDsa: keys2.mlDsa.publicKey },
       preflight: {
-        vcpu: cpus().length,
-        memoryGib: Math.max(1, Math.floor(totalmem() / 1024 ** 3)),
+        vcpu: cpus2().length,
+        memoryGib: Math.max(1, Math.floor(totalmem2() / 1024 ** 3)),
         diskGib: Math.max(1, Math.floor(Number(filesystem.blocks) * Number(filesystem.bsize) / 1024 ** 3)),
-        kvm: existsSync21("/dev/kvm"),
-        snpHost: existsSync21("/dev/sev"),
-        helper: existsSync21(process.env.FZ_METAL_HELPER_SOCKET ?? DEFAULT_METAL_HELPER_SOCKET)
+        kvm: existsSync22("/dev/kvm"),
+        snpHost: existsSync22("/dev/sev"),
+        helper: existsSync22(process.env.FZ_METAL_HELPER_SOCKET ?? DEFAULT_METAL_HELPER_SOCKET)
       }
     };
     const envelope = signRequest(keys2, keys2.ed25519.publicKey, {
@@ -16178,9 +16983,9 @@ if (import.meta.main) {
       metalHostname: process.env.FZ_METAL_HOSTNAME,
       run: (claim) => requestMetalProvision(claim, process.env.FZ_METAL_HELPER_SOCKET ?? DEFAULT_METAL_HELPER_SOCKET),
       metalPreflight: () => ({
-        snpHost: existsSync21("/dev/sev"),
-        kvm: existsSync21("/dev/kvm"),
-        helper: existsSync21(process.env.FZ_METAL_HELPER_SOCKET ?? DEFAULT_METAL_HELPER_SOCKET)
+        snpHost: existsSync22("/dev/sev"),
+        kvm: existsSync22("/dev/kvm"),
+        helper: existsSync22(process.env.FZ_METAL_HELPER_SOCKET ?? DEFAULT_METAL_HELPER_SOCKET)
       }),
       onEvent: (event, detail) => console.log(`[metal-agent] ${event}${detail ? ` ${JSON.stringify(detail)}` : ""}`)
     });
@@ -16235,22 +17040,22 @@ if (import.meta.main) {
     process.on("SIGINT", () => void stop("SIGINT"));
     await new Promise(() => {});
   }
-  if (command2 && ["deploy", "status", "pause", "resume", "pause-key", "resume-key", "stop-key", "start-key", "cancel"].includes(command2)) {
+  if (command3 && ["deploy", "status", "pause", "resume", "pause-key", "resume-key", "stop-key", "start-key", "cancel"].includes(command3)) {
     const revisionArg = args.find((arg) => arg.startsWith("--revision="));
     const socketArg = args.find((arg) => arg.startsWith("--control-socket="));
     const keyArg = args.find((arg) => arg.startsWith("--key="));
     const idArg = args.find((arg) => arg.startsWith("--id="));
     const socketPath = socketArg?.slice("--control-socket=".length) ?? process.env.FZ_CONTROL_SOCKET ?? DEFAULT_CONTROL_SOCKET;
-    const request = command2 === "deploy" ? {
+    const request = command3 === "deploy" ? {
       op: "deploy",
       request: {
         revision: revisionArg?.slice("--revision=".length),
         releaseExecutor: args.includes("--release-executor")
       }
-    } : command2 === "cancel" ? { op: "cancel", id: idArg?.slice("--id=".length) ?? "" } : ["pause-key", "resume-key", "stop-key", "start-key"].includes(command2) ? {
-      op: command2,
+    } : command3 === "cancel" ? { op: "cancel", id: idArg?.slice("--id=".length) ?? "" } : ["pause-key", "resume-key", "stop-key", "start-key"].includes(command3) ? {
+      op: command3,
       key: keyArg?.slice("--key=".length) ?? ""
-    } : { op: command2 };
+    } : { op: command3 };
     try {
       const response = await requestControl(request, socketPath);
       console.log(JSON.stringify(response, null, 2));
@@ -16263,7 +17068,7 @@ if (import.meta.main) {
   const telemetry = new AgentTelemetryRuntime(createAgentTelemetry(resolveAgentTelemetryConfig()));
   telemetry.event("agent.started");
   telemetry.setDraining(false);
-  const attestationSource = existsSync21("/dev/sev-guest") ? createSnpAttestationSource() : undefined;
+  const attestationSource = existsSync22("/dev/sev-guest") ? createSnpAttestationSource() : undefined;
   const running = runAgent({
     socketPath: process.env.FZ_SOCKET_PATH ?? DEFAULT_SOCKET_PATH,
     seedCredential: process.env.FZ_SEED_CREDENTIAL,
@@ -16278,8 +17083,8 @@ if (import.meta.main) {
   const enrolmentStatePath = process.env.FZ_ENROL_STATE_FILE ?? DEFAULT_ENROLMENT_STATE_PATH;
   let binding = loadGuestBinding(enrolmentStatePath, nodeKey);
   const enrolmentCredential = process.env.FZ_ENROL_TOKEN_CREDENTIAL;
-  const enrolmentCredentialAvailable = Boolean(enrolmentCredential && process.env.CREDENTIALS_DIRECTORY && existsSync21(`${process.env.CREDENTIALS_DIRECTORY}/${enrolmentCredential}`));
-  const legacyEnrolmentFileAvailable = Boolean(process.env.FZ_ENROL_TOKEN_FILE && existsSync21(process.env.FZ_ENROL_TOKEN_FILE));
+  const enrolmentCredentialAvailable = Boolean(enrolmentCredential && process.env.CREDENTIALS_DIRECTORY && existsSync22(`${process.env.CREDENTIALS_DIRECTORY}/${enrolmentCredential}`));
+  const legacyEnrolmentFileAvailable = Boolean(process.env.FZ_ENROL_TOKEN_FILE && existsSync22(process.env.FZ_ENROL_TOKEN_FILE));
   if (!binding && (enrolmentCredentialAvailable || legacyEnrolmentFileAvailable) && process.env.FZ_API) {
     binding = await enrolGuestIdentity({
       apiUrl: process.env.FZ_API,
@@ -16357,7 +17162,7 @@ if (import.meta.main) {
   const bootstrapEnabled = process.env.FZ_BOOTSTRAP_PULL === "true";
   const bootstrapCredential = process.env.FZ_BOOTSTRAP_SSH_KEY_CREDENTIAL;
   const bootstrapKeyPath = bootstrapCredential && process.env.CREDENTIALS_DIRECTORY ? `${process.env.CREDENTIALS_DIRECTORY}/${bootstrapCredential}` : undefined;
-  if (bootstrapEnabled && (!binding || !nodeApiUrl || !process.env.FZ_API || !bootstrapKeyPath || !existsSync21(bootstrapKeyPath) || !process.env.FZ_BOOTSTRAP_TARGET_OTLP_ENDPOINT)) {
+  if (bootstrapEnabled && (!binding || !nodeApiUrl || !process.env.FZ_API || !bootstrapKeyPath || !existsSync22(bootstrapKeyPath) || !process.env.FZ_BOOTSTRAP_TARGET_OTLP_ENDPOINT)) {
     throw new Error("agent: bootstrap runner requires enrolment, API, local SSH credential and target OTLP coordinate");
   }
   const bootstrapPull = bootstrapEnabled ? startSshBootstrapPull({
@@ -16433,6 +17238,7 @@ if (import.meta.main) {
       activateService: (request) => requestServiceActivation(request, process.env.FZ_SOFTWARE_HELPER_SOCKET ?? DEFAULT_SOFTWARE_HELPER_SOCKET),
       buildContainer: (request) => requestContainerBuild(request, process.env.FZ_SOFTWARE_HELPER_SOCKET ?? DEFAULT_SOFTWARE_HELPER_SOCKET),
       activateContainer: (request) => requestContainerActivation(request, process.env.FZ_SOFTWARE_HELPER_SOCKET ?? DEFAULT_SOFTWARE_HELPER_SOCKET),
+      applyConnectivity: (request) => requestDeploymentConnectivity(request, process.env.FZ_SOFTWARE_HELPER_SOCKET ?? DEFAULT_SOFTWARE_HELPER_SOCKET),
       projectExec: process.env.FZ_DEPLOY_RUNNER_SOCKET ? (input) => requestDeploymentCommand(input, process.env.FZ_DEPLOY_RUNNER_SOCKET) : undefined
     });
     const staticManager = repository && branch && profile ? createDeploymentManager(managerOptions({ repository, branch, profile }, process.env.FZ_DEPLOY_KEY ?? `${repository}:${branch}:${profile}`)) : bootstrapBundle && branch && profile ? createDeploymentManager({
@@ -16650,6 +17456,8 @@ export {
   selectAgentRelease,
   runAgent,
   restoreAgentRelease,
+  resolveDeploymentTargets,
+  resolveDeploymentInputs,
   resolveAgentTelemetryConfig,
   requestSoftware,
   requestMetalProvision,
@@ -16727,6 +17535,7 @@ export {
   OS_CATALOG,
   METAL_SYSTEMD_CREDENTIALS,
   MAX_AGENT_TARBALL_BYTES,
+  DeploymentInputError,
   DeploymentError,
   DEFAULT_SOFTWARE_HELPER_SOCKET,
   DEFAULT_SOCKET_PATH,