@forgezero/agent 0.1.74 → 0.1.76

package/dist/deploy-plan.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,

package/dist/deploy-providers.d.ts

@@ -11,6 +11,19 @@ export interface DockerProviderConfig {
     defaultNetwork: 'bridge';
     rootless: boolean;
 }
+export interface ContainerdProviderConfig {
+    installScope: 'host';
+    runtimeClass: 'runc';
+    namespace: 'forgezero';
+    snapshotter: 'overlayfs';
+}
+export interface KataProviderConfig {
+    installScope: 'host';
+    runtimeClass: 'kata-qemu-snp';
+    namespace: 'forgezero';
+    hypervisor: 'qemu';
+    confidentialGuest: 'sev-snp';
+}
 export interface NginxProviderConfig {
     installScope: 'host';
     websocket: boolean;
@@ -58,6 +71,12 @@ export declare const providers: {
     readonly docker: {
         readonly require: (options?: RequirementOptions<DockerProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
     };
+    readonly containerd: {
+        readonly require: (options?: RequirementOptions<ContainerdProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
+    };
+    readonly kata: {
+        readonly require: (options?: RequirementOptions<KataProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
+    };
     readonly nginx: {
         readonly require: (options?: RequirementOptions<NginxProviderConfig>) => RequirementDefinition<import("./deploy").JsonObject>;
     };

package/dist/deploy.d.ts

@@ -46,7 +46,33 @@ export type InputDefinition = {
     default?: string;
 };
 export interface ValueReference {
-    readonly $ref: `inputs.${string}` | `steps.${string}.status` | `steps.${string}.outputs.${string}` | `components.${string}.${string}` | `targets.${string}.${string}` | `deployment.${string}`;
+    readonly $ref: `inputs.${string}` | `steps.${string}.status` | `steps.${string}.outputs.${string}` | `components.${string}.${string}` | `targets.${string}.${string}` | `deployment.${string}` | `execution.${string}`;
+}
+export type IntegerValue = number | ValueReference;
+export type StringValue = string | ValueReference;
+export interface ComputeConnectivityDefinition {
+    private?: {
+        mode: 'disabled' | 'private-lan';
+    } | {
+        mode: 'cloudflare-warp';
+        credential: string;
+        network: StringValue;
+    };
+    public?: {
+        mode: 'disabled';
+    } | {
+        mode: 'cloudflare-tunnel';
+        credential: string;
+        zone: StringValue;
+        hostname: {
+            mode: 'static';
+            label: StringValue;
+        } | {
+            mode: 'indexed';
+            prefix: StringValue;
+            startAt?: number;
+        };
+    };
 }
 export type ResolvableJsonValue = JsonPrimitive | ValueReference | readonly ResolvableJsonValue[] | {
     [key: string]: ResolvableJsonValue;
@@ -98,6 +124,11 @@ export interface TargetDefinition {
     kind: 'compute';
     selector: {
         profiles: readonly string[];
+        operatingSystem: {
+            id: 'ubuntu';
+            version: '24.04' | '26.04';
+            architecture: 'x64';
+        };
         confidentialCompute?: 'required' | 'preferred' | 'disabled';
         labels?: Readonly<Record<string, string>>;
     };
@@ -106,11 +137,62 @@ export interface TargetDefinition {
         desired: number | ValueReference;
         maximum: number;
     };
+    /**
+     * Capacity reserved for every stable target slot. This is placement intent,
+     * not an application cgroup limit. The API first binds an eligible idle
+     * compute with at least this unreserved capacity; provisioning is allowed
+     * only when the separately approved control-plane policy permits it.
+     */
+    allocation: {
+        execution: 'native' | 'oci-runc' | 'oci-kata-qemu-snp';
+        sharing: 'exclusive' | 'shared';
+        resources: {
+            cpuCores: IntegerValue;
+            memoryMiB: IntegerValue;
+            storageGiB: IntegerValue;
+        };
+        existing: 'prefer' | 'require';
+    };
+    /** Required only when the control plane may create capacity after reuse is exhausted. */
+    provisioning?: {
+        planKey: string;
+        regionKey: string;
+        imageKey: string;
+        environmentKey: string;
+        ownership: 'platform' | 'tenant-metal';
+        metalHostname?: string;
+        maxMonthlySpendMinor: string;
+    };
+    /** Per-slot connectivity intent. Credential names resolve through the scoped Vault, never to plan values. */
+    connectivity?: ComputeConnectivityDefinition;
     placement?: {
         spreadBy?: readonly ('metal' | 'region' | 'zone')[];
         antiAffinity?: readonly string[];
     };
 }
+/** Compact TypeScript input normalized into the explicit wire shape above. */
+export interface ComputePoolDefinition {
+    profiles: readonly string[];
+    replicas: number | {
+        minimum: number;
+        desired: number | ValueReference;
+        maximum: number;
+    };
+    resources: {
+        cpuCores: IntegerValue;
+        memoryMiB: IntegerValue;
+        storageGiB: IntegerValue;
+    };
+    os?: 'ubuntu-24.04' | 'ubuntu-26.04';
+    runtime?: 'native' | 'oci-runc' | 'oci-kata-qemu-snp';
+    isolation?: 'standard' | 'sev-snp';
+    sharing?: 'exclusive' | 'shared';
+    reuse?: 'prefer' | 'require';
+    provisioning?: TargetDefinition['provisioning'];
+    connectivity?: ComputeConnectivityDefinition;
+    labels?: Readonly<Record<string, string>>;
+    placement?: TargetDefinition['placement'];
+}
 export interface RequirementDefinition<TConfig extends JsonObject = JsonObject> {
     capability: string;
     provider: string;
@@ -195,6 +277,8 @@ export type ApplicationRuntime = {
     kind: 'container';
     provider: string;
     requirement: string;
+    /** runc shares the compute kernel; Kata creates one measured QEMU SNP workload VM. */
+    runtimeClass?: 'runc' | 'kata-qemu-snp';
     image: {
         source: {
             kind: 'build';
@@ -395,6 +479,8 @@ export declare const ref: {
     component: (component: string, property: string) => ValueReference;
     target: (target: string, property: string) => ValueReference;
     deployment: (property: string) => ValueReference;
+    /** Secret-free control-plane assignment of the compute executing this step. */
+    execution: (property: "targetName" | "slot" | "releaseExecutor" | "runtime" | "cpuCores" | "memoryMiB" | "storageGiB") => ValueReference;
 };
 export declare const conditions: {
     all: (...values: Condition[]) => Condition;
@@ -425,7 +511,7 @@ export declare const credential: {
     }) => CredentialDefinition;
 };
 export declare const target: {
-    compute: (value: Omit<TargetDefinition, "kind">) => TargetDefinition;
+    compute: (value: ComputePoolDefinition | Omit<TargetDefinition, "kind">) => TargetDefinition;
 };
 export declare function requirement<TConfig extends JsonObject>(value: RequirementDefinition<TConfig>): RequirementDefinition<TConfig>;
 export declare function application(value: Omit<ApplicationComponent, 'kind'>): ApplicationComponent;
@@ -436,4 +522,4 @@ export declare function workflow(value: WorkflowDefinition): WorkflowDefinition;
 export declare function defineDeployment<const T extends DeploymentSource>(definition: T): T;
 export { actions } from './deploy-actions';
 export { providers } from './deploy-providers';
-export type { ArangoDbProviderConfig, BunProviderConfig, CloudflaredProviderConfig, DockerProviderConfig, NginxProviderConfig, OpenSshProviderConfig, SystemdProviderConfig, UfwProviderConfig, WarpProviderConfig } from './deploy-providers';
+export type { ArangoDbProviderConfig, BunProviderConfig, CloudflaredProviderConfig, ContainerdProviderConfig, DockerProviderConfig, KataProviderConfig, NginxProviderConfig, OpenSshProviderConfig, SystemdProviderConfig, UfwProviderConfig, WarpProviderConfig } from './deploy-providers';

package/dist/deploy.js

@@ -6,6 +6,9 @@ var actions = {
   software: {
     ensure: (withValue, options) => action("forgezero.software/ensure@1", withValue, options)
   },
+  network: {
+    ensure: (withValue, options) => action("forgezero.network/ensure@1", withValue, options)
+  },
   exec: {
     argv: (withValue, options) => action("forgezero.exec/argv@1", withValue, options)
   },
@@ -49,6 +52,23 @@ var providers = {
       rootless: false
     })
   },
+  containerd: {
+    require: (options = { version: "ubuntu-26.04" }) => define("runtime.container", "forgezero.containerd", options, {
+      installScope: "host",
+      runtimeClass: "runc",
+      namespace: "forgezero",
+      snapshotter: "overlayfs"
+    })
+  },
+  kata: {
+    require: (options = { version: "4.0.0" }) => define("runtime.container", "forgezero.kata", options, {
+      installScope: "host",
+      runtimeClass: "kata-qemu-snp",
+      namespace: "forgezero",
+      hypervisor: "qemu",
+      confidentialGuest: "sev-snp"
+    })
+  },
   nginx: {
     require: (options = { version: "ubuntu-26.04" }) => define("proxy.http", "forgezero.nginx", options, {
       installScope: "host",
@@ -98,7 +118,8 @@ var ref = {
   stepOutput: (step2, output) => ({ $ref: `steps.${step2}.outputs.${output}` }),
   component: (component, property) => ({ $ref: `components.${component}.${property}` }),
   target: (target, property) => ({ $ref: `targets.${target}.${property}` }),
-  deployment: (property) => ({ $ref: `deployment.${property}` })
+  deployment: (property) => ({ $ref: `deployment.${property}` }),
+  execution: (property) => ({ $ref: `execution.${property}` })
 };
 var conditions = {
   all: (...values) => ({ all: values }),
@@ -128,7 +149,33 @@ var credential = {
   })
 };
 var target = {
-  compute: (value) => ({ kind: "compute", ...value })
+  compute: (value) => {
+    if ("selector" in value)
+      return { kind: "compute", ...value };
+    const replicas = typeof value.replicas === "number" ? { minimum: value.replicas, desired: value.replicas, maximum: value.replicas } : value.replicas;
+    const execution = value.runtime ?? "native";
+    const isolation = value.isolation ?? (execution === "oci-kata-qemu-snp" ? "sev-snp" : "standard");
+    const os = value.os ?? (isolation === "sev-snp" ? "ubuntu-26.04" : "ubuntu-24.04");
+    return {
+      kind: "compute",
+      selector: {
+        profiles: value.profiles,
+        operatingSystem: { id: "ubuntu", version: os === "ubuntu-26.04" ? "26.04" : "24.04", architecture: "x64" },
+        confidentialCompute: isolation === "sev-snp" ? "required" : "disabled",
+        ...value.labels ? { labels: value.labels } : {}
+      },
+      cardinality: replicas,
+      allocation: {
+        execution,
+        sharing: value.sharing ?? "exclusive",
+        resources: value.resources,
+        existing: value.reuse ?? "prefer"
+      },
+      ...value.provisioning ? { provisioning: value.provisioning } : {},
+      ...value.connectivity ? { connectivity: value.connectivity } : {},
+      ...value.placement ? { placement: value.placement } : {}
+    };
+  }
 };
 function requirement(value) {
   return value;

package/dist/deployment-connectivity.d.ts

@@ -0,0 +1,63 @@
+export interface DeploymentConnectivityIntent {
+    private?: {
+        mode: 'disabled' | 'private-lan';
+    } | {
+        mode: 'cloudflare-warp';
+        credential: string;
+        network: string;
+    };
+    public?: {
+        mode: 'disabled';
+    } | {
+        mode: 'cloudflare-tunnel';
+        credential: string;
+        hostname: string;
+        tunnelKey: string;
+        service: {
+            protocol: 'http';
+            port: number;
+        };
+    };
+}
+/** Connector-scoped capabilities delivered only inside the hybrid-sealed node claim. */
+export interface DeploymentConnectivityCapabilities {
+    public?: {
+        tunnelId: string;
+        connectorToken: string;
+    };
+    private?: {
+        connectorId: string;
+        connectorToken: string;
+    };
+}
+export interface DeploymentConnectivityRequest {
+    key: string;
+    intent: DeploymentConnectivityIntent;
+    capabilities: DeploymentConnectivityCapabilities;
+}
+export interface DeploymentConnectivityEvidence {
+    key: string;
+    public?: {
+        hostname: string;
+        tunnelId: string;
+        unit: string;
+        active: true;
+    };
+    private?: {
+        network: string;
+        connectorId: string;
+        unit: string;
+        active: true;
+    };
+}
+export interface DeploymentConnectivityHost {
+    seal(name: string, path: string, value: string): Promise<void>;
+    write(path: string, content: string, mode: number): void;
+    exec(argv: readonly string[]): Promise<{
+        exitCode: number;
+        output: string;
+    }>;
+    sleep(ms: number): Promise<void>;
+}
+/** Apply only connector-scoped capabilities; the broad Cloudflare token never reaches this helper. */
+export declare function applyDeploymentConnectivity(request: DeploymentConnectivityRequest, host?: DeploymentConnectivityHost): Promise<DeploymentConnectivityEvidence>;