@forgezero/agent 0.1.74 → 0.1.75

package/dist/deploy-compiler.js

@@ -38,6 +38,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));
@@ -93,6 +100,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"] },
@@ -113,6 +122,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"))
@@ -190,7 +203,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 };
@@ -430,10 +443,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`);
@@ -444,7 +456,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`);
@@ -478,6 +492,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")
@@ -509,6 +540,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)
@@ -545,6 +588,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`);
@@ -741,15 +786,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" || !NAME.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)
@@ -762,8 +812,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)
@@ -777,13 +927,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,
@@ -825,6 +996,14 @@ function compileDeployment(sourceValue) {
     });
     plannedWorkflows.push({ id: workflowName, ...workflowValue.concurrency ? { concurrency: workflowValue.concurrency } : {}, stages: plannedStages });
   }
+  const deployWorkflow = plannedWorkflows.find(({ id }) => id === "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,
@@ -936,8 +1115,10 @@ export default defineDeployment({
 		inputs: { replicas: input.integer({ minimum: 1, maximum: 32, default: 1 }) },
 		targets: {
 			app: target.compute({
-				selector: { profiles: ['app'] },
-				cardinality: { minimum: 1, desired: input.ref('replicas'), maximum: 32 }
+				profiles: ['app'],
+				replicas: { minimum: 1, desired: input.ref('replicas'), maximum: 32 },
+				resources: { cpuCores: 1, memoryMiB: 512, storageGiB: 8 },
+				os: 'ubuntu-24.04', runtime: 'native', isolation: 'standard', reuse: 'require'
 			})
 		},
 		requirements: { bun: providers.bun.require() },

package/dist/deploy-file.js

@@ -4,22 +4,30 @@ import {
   accessSync,
   chmodSync,
   copyFileSync,
+  createReadStream,
   existsSync,
   mkdtempSync,
   mkdirSync,
   readFileSync,
   renameSync,
   rmSync,
+  statSync,
   symlinkSync,
   unlinkSync,
   writeFileSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node: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",
@@ -49,6 +57,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" },
@@ -57,6 +67,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" },
@@ -65,6 +76,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" } },
@@ -76,6 +89,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" } },
@@ -92,6 +106,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;
@@ -111,14 +165,28 @@ var runSoftwareCommand = async (argv, env = {}) => {
   return { exitCode, output: `${stdout}${stderr}` };
 };
 var run = runSoftwareCommand;
-var download = async (url, destination, sha256) => {
-  const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(120000) });
+var download = async (url, destination, sha256, 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") !== sha256)
+  const declared = Number(response.headers.get("content-length") ?? 0);
+  if (declared > maximumBytes)
+    throw new Error("download exceeds reviewed size bound");
+  if (existsSync(destination))
+    throw new Error("download destination already exists");
+  await Bun.write(destination, response);
+  chmodSync(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") !== sha256) {
+    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) => {
@@ -126,6 +194,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 (existsSync(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;
+  chmodSync("/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}`);
+    chmodSync(`/usr/local/bin/${binary}`, 493);
+  }
+  mkdirSync("/etc/containerd", { recursive: true, mode: 493 });
+  const expected = CONTAINERD_CONFIG(false);
+  const kataExpected = CONTAINERD_CONFIG(true);
+  if (existsSync(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 (!existsSync(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 (!existsSync(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 (!existsSync(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 (!existsSync("/opt/kata/bin/containerd-shim-kata-v2") || !existsSync(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 (existsSync(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 (!existsSync(KATA_ACTIVE_CONFIG_PATH))
+    copyFileSync(KATA_SNP_CONFIG_PATH, KATA_ACTIVE_CONFIG_PATH);
+  chmodSync(KATA_ACTIVE_CONFIG_PATH, 420);
+  try {
+    unlinkSync("/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 (!existsSync(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)) {
@@ -143,6 +311,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 = existsSync(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 = existsSync(CONTAINERD_CONFIG_PATH) ? readFileSync(CONTAINERD_CONFIG_PATH, "utf8") : "";
+      const activeConfig = existsSync(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(existsSync) && ["/sys/module/kvm_amd/parameters/sev", "/sys/module/kvm_amd/parameters/sev_snp"].every((parameter) => existsSync(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 === (existsSync(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;
@@ -194,6 +382,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");
@@ -275,7 +474,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 };