diff --git a/nvx-rs/src/host/template/plan/tests.rs b/nvx-rs/src/host/template/plan/tests.rs
index 1097a3edb..76e910460 100644
--- a/nvx-rs/src/host/template/plan/tests.rs
+++ b/nvx-rs/src/host/template/plan/tests.rs
@@ -11,6 +11,7 @@ use crate::host::network::{EgressRule, ForwardProtocol, LoopbackForward, Network
 use crate::host::sandbox::distro::{BINDING_VERSION, DISTRO_POLICY_REVISION};
 use crate::host::sandbox::{SandboxDistro, SandboxNetwork, SandboxSettings};
 use crate::host::seal::SEAL_VERSION;
+use crate::protocol::cmdline;
 use crate::protocol::root::RootImage;
 use crate::uuid::Uuid;
 
@@ -555,6 +556,13 @@ fn the_command_line_holds_only_tokens_of_openvmms_platform_allowlist() {
         }
         for token in &tokens {
             assert!(openvmm::admits(token), "{token} of {template:?}");
+            // OpenVMM splits the command line at ASCII whitespace, and the kernel at its own,
+            // which also holds the vertical tab and 0xa0: no token holds either, so both split
+            // the command line into the same tokens.
+            assert!(
+                token.is_ascii() && !token.bytes().any(cmdline::is_space),
+                "{token:?} of {template:?}"
+            );
         }
         // The command line of the template's devices names the root of its plan, which a clone
         // binds, and which the allowlist refuses: the template's replaces it.
diff --git a/nvx-rs/tests/vectors/README.md b/nvx-rs/tests/vectors/README.md
index b679d522e..d4ed4a2ac 100644
--- a/nvx-rs/tests/vectors/README.md
+++ b/nvx-rs/tests/vectors/README.md
@@ -83,7 +83,10 @@ command-line tokens of a capture at OpenVMM's platform tier, and
 `microvm_control_tty_command_line.rs`, the constant of
 `openvmm/openvmm_defs/src/microvm.rs` that names the control tty's token, which
 the function reads. The tests of `nvx::host::template` compile them, and check
-each token of a template's kernel command line with OpenVMM's own function.
+each token of a template's kernel command line with OpenVMM's own function. The
+runtime adapter in `tests/runtime-adapter/` compiles them too, as the allowlist
+with which the guest agent of a template's VM checks its kernel command line,
+and its tests pin the set of tokens that they admit.
 
 The tests cannot call OpenVMM's broker or its allowlist: OpenVMM's workspace
 needs a later Rust release than `nvx`'s minimum, and the `nvx-rs` job cannot
diff --git a/tests/runtime-adapter/README.md b/tests/runtime-adapter/README.md
index b2df8c916..e641f76c0 100644
--- a/tests/runtime-adapter/README.md
+++ b/tests/runtime-adapter/README.md
@@ -682,8 +682,11 @@ kernel finds no parameter `nvx_snapshot_tier=platform` boots cold: the worker
 goes on as above, whatever else the command line holds. With it, the VM is a
 template's, whose snapshot holds the platform's invariant configuration alone,
 which every clone shares. So the worker accepts only the parameters of the
-platform tier's allowlist, `template::is_platform_token`, which OpenVMM's
-capture of a platform snapshot allows too, byte for byte:
+platform tier's allowlist, `template::is_platform_token`: OpenVMM's own check,
+which the adapter compiles from the excerpts of OpenVMM's sources that NVX's
+tests keep in `nvx-rs/tests/vectors/openvmm/`, so that the worker accepts
+exactly what OpenVMM's capture of a platform snapshot admits, as text, byte for
+byte:
 
 - `earlycon=xe9`, `console=hvc0`, `console=hvc1`, `reboot=t`, `panic=-1`,
   `nvx_sandbox=1`, `nvx_config=0xd0010000,65536`,
@@ -692,10 +695,13 @@ capture of a platform snapshot allows too, byte for byte:
   `virtnet_mask=`, `virtnet_gw=`, `virtnet_dns=`, `virtnet_ip6=`, and
   `virtnet_gw6=`, with any value that the host chooses.
 
-It refuses any other parameter, and a double quote, which the kernel drops from
-a parameter, or `--`, after which the kernel hands the rest of the command line
-to init, though init may still read it from `/proc/cmdline`: OpenVMM refuses
-both in the command line of a VM with a control console. Otherwise, the worker,
+It refuses any other parameter, one that is not UTF-8 text among them, and a
+double quote, which the kernel drops from a parameter, or `--`, after which the
+kernel hands the rest of the command line to init, though init may still read
+it from `/proc/cmdline`: OpenVMM refuses both in the command line of a VM with
+a control console. OpenVMM checks the tokens that it finds at ASCII
+whitespace, while the kernel also splits at the vertical tab and at 0xa0, so
+the worker checks the parameters that the kernel finds. Otherwise, the worker,
 through `worker::capture::capture_on_terminal`:
 
 1. opens the control tty, in raw mode, as the worker of a VM that boots cold
@@ -1133,6 +1139,57 @@ The steps of a launch, in order, are:
 A value that names no step or action is a usage error. Without the variable,
 the hook does nothing.
 
+### Templates
+
+`runtime-adapter-host create` serves a template of the guest agent from an NVX
+template store, `nvx::host::template::Store`, with `Store::create_template`: a
+generation of the template's capture class that the store holds, and that is
+eligible at the host's time, or else a new one, which the store captures
+through NVX's supervisor and publishes. `capture::Request` holds what the
+command's options choose of the template, and `Request::capture` returns NVX's
+`Capture` of it:
+
+- the adapter's plan of the placeholder, with the template's network, if any,
+  and the placeholder's binding, which the command plans and stages as `stage`
+  plans and stages an image. The placeholder is a trusted artifact of the
+  platform, whose length is the capacity of every clone's image, and the
+  capture refuses one that anyone else may change;
+- the capture class, from which the store takes the slot that serializes the
+  class's captures, and the template's compatibility key: the runtime identity
+  of the adapter's VMs, with the guest agent's build,
+  `runtime-adapter-guest/BUILD`, the backend and the CPU profile, the
+  processors, all online at boot, the RAM and its capacity, the geometries of
+  the placeholder and of the dormant scratch, as OpenVMM presents a sandbox
+  block device, which `capture::geometry` gives, and the network;
+- NVX's artifacts, with the initramfs that puts the guest agent in place of
+  NVX's agents, which the command writes into a directory of its own in the
+  system's temporary directory, private to the current user, as a launch
+  writes it into the sandbox's private store, and removes once the creation
+  returns.
+
+NVX's store launches the capture's VM from the capture's transaction, in the
+class's slot, whose VMM listens there, beside the snapshot's destination, as
+OpenVMM requires. On Linux, the path of that socket,
+`captures/C/transaction/control.sock` in the store, must fit a Unix socket's,
+so NVX refuses a store whose path is too long for it.
+
+The capture boots the template's VM with the kernel command line
+`nvx_sandbox=1`, to which OpenVMM adds the platform tier's tokens,
+`nvx_snapshot_tier=platform` among them, so the worker of the guest agent
+captures the VM in [template mode](#template-mode) before it assembles any root,
+and the capture ends the VM. The store checks what the VM left, and publishes
+the snapshot as its next generation, with the record of its capture and its
+compatibility key, whose kernel command line holds the platform tier's tokens
+alone: neither the placeholder's identity nor a root's tokens. The template has
+a NIC exactly when its network lets something through: a network that denies
+egress, ingress, and host-loopback access, without a proxy, attaches none, as
+no network does. NVX refuses a network whose policy no template takes, one that
+allows ingress or host-loopback access both ways, before any VM starts, and the
+command refuses a class that no capture takes, such as one of 3 processors,
+before it creates the store. A capture that fails leaves the store's
+generations as they were, and the command's diagnostic names the log of the VMM
+of the class's latest capture, when the class's slot keeps one.
+
 ### Commands
 
 Each command of `runtime-adapter-host` but `stage` takes NVX's artifacts from
@@ -1202,6 +1259,22 @@ the directory that `NVX_ARTIFACTS_DIR` names, and the guest agent's build from
   mapping, the launch sends no more of the table, nor `Start`, stops the guest,
   which tears down the root, waits for the VM to end, abandons the launch, and
   checks that the VM ended with a success and a complete teardown.
+- `create STORE --guest-agent PATH --distro FORMAT:PATH --distro-identity UUID [--hypervisor NAME] [--cpu-profile PROFILE] [--processors N] [--memory MIB] [--memory-capacity MIB] [--scratch-length BYTES] [--network FILE]`
+  serves a [template](#templates) of the guest agent PATH from the template
+  store STORE, which it creates if needed: a generation of the template's
+  class that the store holds, and that is eligible at the host's time, or else
+  a new one, which the store captures and publishes. The placeholder is the
+  file PATH, an EROFS file system, `erofs`, or a GPT disk, `gpt`, with the
+  identity UUID. The template's VM runs on the hypervisor NAME, as a launch's
+  does, with the CPU profile PROFILE, `auto` by default, as OpenVMM's
+  `--cpu-profile` takes it, N processors, 1 by default, all online at boot,
+  MIB mebibytes of RAM, 256 by default, a RAM capacity of MIB mebibytes, its
+  RAM by default, and a dormant scratch of BYTES bytes, 64 MiB by default. It
+  has one NIC under the policy of the [network](#networks) FILE, unless the
+  policy lets nothing through, and none without a network. The command reads
+  the network before anything else, as a launch does, and checks the class
+  before it creates the store, then prints the generation once the store has
+  committed it.
 - `reattach STORE` takes the sandbox's lock, and reattaches to its VM, which
   another process launched, and which it holds, although the VM is not its
   child, through its verified process identity. It reads the capability from
@@ -1267,8 +1340,12 @@ the probe named PROBE found), `exec.N.KEY` (what execution N did: its `launch`,
 `stdout,stderr`, or `none`; whether it `settled`, `reusable` or `fenced`; and
 its `stdout` and `stderr`), `stopped` (`graceful`, `forced`, or `timed-out`),
 `outcome` (such as `success 0`, or `guest-exit 14` once the assembly failed),
-and `teardown` (`complete` or `incomplete`: whether the VMM's teardown of the VM
-completed, which the outcome report records apart from the root's). Values
+`teardown` (`complete` or `incomplete`: whether the VMM's teardown of the VM
+completed, which the outcome report records apart from the root's), `created`
+(`captured` once a capture made the template's generation, or `existing` once
+the store held it), `generation` (the generation's number in the template
+store), and `key` and `class` (the identities of its compatibility key and of
+its capture class, in hexadecimal). Values
 escape `\`, newlines, and carriage returns as `\\`, `\n`, and `\r`, and each
 byte of a program's output that is not part of UTF-8 text as `\xHH`. The
 commands exit with 0 once they did what they were asked, `exec` once every
@@ -1308,13 +1385,17 @@ cancellation of one that it gives up on in the step that ends it, without grace
 or settlement time, and which cancels one whose stream outgrows the 16 MiB that
 it keeps. Those of `template` check the platform tier's allowlist, token by
 token, against the tokens that OpenVMM's capture of a platform snapshot allows
-and refuses, and template mode: a command line in which the kernel finds no
-platform tier boots cold, whatever else it holds, and one with it boots a
-template's VM if it holds the tier's tokens alone, between any of the kernel's
-whitespace, and is refused otherwise, for a parameter outside the allowlist at
-its start, in its middle, or at its end, or within a platform token's value,
-after a vertical tab or the byte 0xa0, which the kernel takes for whitespace
-and a split at ASCII whitespace does not, for a double quote, and for `--`. In
+and refuses, through NVX's copy of OpenVMM's check, which refuses a token that
+is not UTF-8 text, and admits by its prefix one that the kernel splits in two at
+a vertical tab or at 0xa0, and template mode: a command
+line in which the kernel finds no platform tier boots cold, whatever else it
+holds, and one with it boots a template's VM if it holds the tier's tokens
+alone, between any of the kernel's whitespace, and is refused otherwise, for a
+parameter outside the allowlist at its start, in its middle, or at its end, or
+within a platform token's value, after a vertical tab or the byte 0xa0, which
+the kernel takes for whitespace and a split at ASCII whitespace does not, for a
+platform token that the no-break space's first byte leaves without UTF-8 text,
+for a double quote, and for `--`. In
 the guest-only configuration, the unit tests of `worker::probes`
 cover what the probes read: the mount table with its escapes, the kernel's
 records of a process, `os-release`, and the guest's memory, and the probes and
@@ -1617,7 +1698,24 @@ Windows:
   plan refuses, or that it cannot read, with status 1 before it needs NVX's
   artifacts or creates the store, and passes one that the plan takes;
 - the command lines that the host program refuses, each with status 2, those of
-  `exec` and of `--workload-identity` included.
+  `exec`, of `--workload-identity`, and of `create` included.
+
+`tests/template_capture.rs` checks, in the host-only configuration, on Linux
+and Windows:
+
+- the capture that `capture::Request::capture` makes of a request: the
+  adapter's plan of the placeholder, as the host program stages it, with the
+  request's network, over RAM, which no template keeps; the placeholder's
+  binding, the policy revision, and the artifacts, with the initramfs that it
+  names; and the class, with the runtime identity of the adapter's VMs and the
+  guest agent's build, the backend, the `auto` CPU profile, every processor
+  online at boot, the RAM and its capacity, the geometries that OpenVMM
+  presents, of 512-byte logical blocks, and the network, which names the class:
+  a class without it is another;
+- `runtime-adapter-host create` with a network that the plan refuses, or that
+  it cannot read, which it refuses with status 1 before it needs NVX's
+  artifacts or creates the store, and with one that the plan takes, or none,
+  which goes on to need NVX's artifacts.
 
 `tests/step_hook.rs` checks, in the host-only configuration, on Linux and
 Windows, the [step hook](#the-step-hook): the values of
@@ -1826,19 +1924,53 @@ With the file system's `needs_recovery` bit clear, `noload` bypasses that scan
 and the root remains usable. With that bit set, the assembly refuses the
 layer before any mount: `noload` is not permission to ignore required recovery.
 
+### Template scenarios
+
+`tests/vm_template.rs` creates [templates](#templates) on a real hypervisor, in
+the host-only configuration, through `runtime-adapter-host create`. Each test
+stages its placeholder, a copy of NVX's Ubuntu EROFS image with its manifest,
+in a directory that only its user may change, as a platform stages its trusted
+artifacts, and creates a template of it in a template store of its own:
+
+| Test | Template | Expects |
+| --- | --- | --- |
+| `a_template_without_a_network_has_no_nic` | 2 processors, 256 MiB of RAM with a capacity of 512 MiB, a 32 MiB scratch, and no network | A captured template without a NIC |
+| `a_network_that_lets_nothing_through_has_no_nic` | A network that denies egress, ingress, and host-loopback access, without a proxy | A captured template without a NIC |
+| `an_egress_network_has_its_nic` | Egress allowed | A captured template with a NIC |
+| `an_allow_rule_has_its_nic` | Egress denied but for one TCP rule to the gateway, with outbound host-loopback access | A captured template with a NIC |
+| `outbound_host_loopback_has_its_nic` | Egress allowed, with outbound host-loopback access | A captured template with a NIC |
+| `a_proxy_only_network_has_its_nic` | A proxy-only network | A captured template with a NIC |
+| `ingress_is_refused_before_any_vm_starts` | Ingress allowed | NVX's refusal, with status 1, a store without a generation, and no VMM's log or transaction in any slot |
+| `host_loopback_both_ways_is_refused_before_any_vm_starts` | Host-loopback access both ways | NVX's refusal, with status 1, a store without a generation, and no VMM's log or transaction in any slot |
+| `a_class_that_no_capture_takes_is_refused_before_the_store` | 3 processors | NVX's refusal of the class, with status 1, before the store exists |
+
+Unless a test says otherwise, a template has 1 processor, 256 MiB of RAM, its
+capacity, and a 64 MiB scratch. A captured template is the store's one
+generation, whose payload holds the record of its capture, its key, and its
+snapshot, and whose key holds what the test asked for: the runtime identity of
+the adapter's VMs with the guest agent's build, the backend, the processors, of
+which a restore activates none, as all are online at boot, the RAM and its
+capacity, the geometries of the placeholder and of the scratch, the NIC, and a
+kernel command line of the platform tier's tokens alone, with the processors
+and, exactly with a NIC, the NIC's addresses, which names neither the
+placeholder's identity nor a root's tokens. Its class's slot then holds no
+transaction and records no launch, and a second creation prints `existing`,
+with the same generation, key, and class, without a capture: the slot's log of
+the VMM stays as the capture left it.
+
 ### Running the VM tests
 
-The VM tests, `tests/vm_restart.rs`, `tests/vm_steps.rs`, and
-`tests/vm_layered.rs`, share their sandboxes and the fixtures of their layered
-roots through `tests/common`. A test that fails ends the VM that it left
-running, and the host program that it left paused, and keeps the sandbox's
-directory, whose path it prints, unless it can confirm that the VM ended. The
-tests boot VMs, so they are ignored. They read the hypervisor from
-`NVX_HYPERVISOR`, through `nvx::Hypervisor::from_env_or_default`, NVX's
-artifacts, with their install metadata and the fixtures, from
-`NVX_ARTIFACTS_DIR`, and the guest agent from `RUNTIME_ADAPTER_GUEST`. In a
-checkout where `nvx-rs download` installed NVX's artifacts, and with the
-scratch template, run them in this directory with:
+The VM tests, `tests/vm_restart.rs`, `tests/vm_steps.rs`,
+`tests/vm_layered.rs`, and `tests/vm_template.rs`, share their sandboxes and
+the fixtures of their layered roots through `tests/common`. A test that fails
+ends the VM that it left running, and the host program that it left paused,
+and keeps the sandbox's directory, whose path it prints, unless it can confirm
+that the VM ended. The tests boot VMs, so they are ignored. They read the
+hypervisor from `NVX_HYPERVISOR`, through
+`nvx::Hypervisor::from_env_or_default`, NVX's artifacts, with their install
+metadata and the fixtures, from `NVX_ARTIFACTS_DIR`, and the guest agent from
+`RUNTIME_ADAPTER_GUEST`. In a checkout where `nvx-rs download` installed NVX's
+artifacts, and with the scratch template, run them in this directory with:
 
 ```bash
 cargo build --locked --release --features guest \
@@ -1875,10 +2007,11 @@ configuration. A change to the adapter is a test input of CI's
 NVX microVM tests. Their
 [workflow](../../.github/workflows/run-nvx-microvm-tests.yml) builds the
 host-only configuration on each backend, in the jobs that run the guest and
-sandbox steps, and runs its ignored tests, the adapter's VM scenarios, with
-`NVX_HYPERVISOR` naming the backend, `NVX_ARTIFACTS_DIR` the checkout, into
-which the job downloaded NVX's artifacts, their provenance, and the fixtures
-of the layered scenarios with the guest artifacts, as NVX's own layered
-scenarios take them, and `RUNTIME_ADAPTER_GUEST` the guest agent. The Linux
-jobs build the guest agent first, and the Windows job takes the one that CI's
-`distro-artifacts` job builds on Linux.
+sandbox steps, and runs its ignored tests, the adapter's VM scenarios and
+template captures, with `NVX_HYPERVISOR` naming the backend,
+`NVX_ARTIFACTS_DIR` the checkout, into which the job downloaded NVX's
+artifacts, their provenance, and the fixtures of the layered scenarios with
+the guest artifacts, as NVX's own layered scenarios take them, and
+`RUNTIME_ADAPTER_GUEST` the guest agent. The Linux jobs build the guest agent
+first, and the Windows job takes the one that CI's `distro-artifacts` job
+builds on Linux.
diff --git a/tests/runtime-adapter/src/bin/runtime-adapter-host.rs b/tests/runtime-adapter/src/bin/runtime-adapter-host.rs
index 8dba4d3f3..443189922 100644
--- a/tests/runtime-adapter/src/bin/runtime-adapter-host.rs
+++ b/tests/runtime-adapter/src/bin/runtime-adapter-host.rs
@@ -68,6 +68,30 @@
 //!   with the stage's status. If the guest fails a mapping, the launch sends no more of the table,
 //!   nor `Start`, asks the guest agent to stop, which tears down the root, waits for the VM to
 //!   end, abandons it, and checks that the VM ended with success and a complete teardown.
+//! - `runtime-adapter-host create STORE --guest-agent PATH --distro FORMAT:PATH --distro-identity
+//!   UUID [--hypervisor NAME] [--cpu-profile PROFILE] [--processors N] [--memory MIB]
+//!   [--memory-capacity MIB] [--scratch-length BYTES] [--network FILE]` serves a template of the
+//!   guest agent PATH from the template store STORE, an `nvx::host::template::Store`, which it
+//!   creates if needed: a generation of the template's class that the store holds, and that is
+//!   eligible at the host's time, or else a new one, which the store captures and publishes, with
+//!   `Store::create_template`. The options choose the class; see `runtime_adapter::capture`. The
+//!   placeholder is the raw file PATH, an EROFS filesystem, `erofs`, or a GPT disk, `gpt`, with
+//!   the identity UUID, a trusted artifact of the platform, whose length is the capacity of every
+//!   clone's image. The template's VM runs on the hypervisor NAME, as a launch's does, with the CPU
+//!   profile PROFILE, `auto` by default, N processors, 1 by default, all online at boot, MIB
+//!   mebibytes of RAM, 256 by default, and a RAM capacity of MIB mebibytes, its RAM by default, to
+//!   which a restore may expand it, and a dormant scratch of BYTES bytes, 64 MiB by default. It has
+//!   one NIC under the policy of the network FILE, which the creation reads as a launch reads its
+//!   network, unless the policy lets nothing through, and none without a network. The creation
+//!   reads the network before anything else, then stages the placeholder as `stage` stages an
+//!   image, verifying it explicitly, which hashes it only when a manifest is beside it, and checks
+//!   the class before it creates the store. A capture boots the template's VM through NVX's
+//!   supervisor, with the guest agent in place of NVX's agents, which captures the VM before it
+//!   assembles any root, in template mode; see `runtime_adapter::template`. The store checks what
+//!   the VM left, and publishes the snapshot as its next generation. The command writes the
+//!   initramfs of the guest agent into a directory of its own in the system's temporary
+//!   directory, private to the current user, which it removes once the creation returns, and
+//!   prints the generation only once the store has committed it.
 //! - `runtime-adapter-host reattach STORE` reattaches to the VM of STORE, which an earlier process
 //!   launched and which it holds although it is not its child, attaches a new session to it, in
 //!   the session's next epoch, and exchanges a `Ping`, leaving the VM running.
@@ -140,7 +164,12 @@
 //!   - `stdout` and `stderr`: the program's standard output and error;
 //! - `stopped`: how the stop ended: `graceful`, `forced`, or `timed-out`;
 //! - `outcome`: the category and status code of the VM's outcome report, such as `success 0`;
-//! - `teardown`: whether the VM's teardown completed: `complete` or `incomplete`.
+//! - `teardown`: whether the VM's teardown completed: `complete` or `incomplete`;
+//! - `created`: how `create` served the template: `captured`, with a generation that a capture
+//!   made and the store published, or `existing`, with one that the store held;
+//! - `generation`, `key`, and `class`: the store generation of the template that `create` served,
+//!   and the identities of its compatibility key and of its capture class, each 64 hexadecimal
+//!   digits.
 //!
 //! Values escape `\`, newlines, and carriage returns as `\\`, `\n`, and `\r`, and each byte of a
 //! program's output that is not part of UTF-8 text as `\xHH`, with two hexadecimal digits.
@@ -160,23 +189,29 @@
 use std::env;
 use std::error::Error;
 use std::ffi::OsString;
+use std::fs;
+use std::io;
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 use std::time::{Duration, Instant};
 
 use nvx::exec::{Cause, Key, Limits, Outcome, Status, Stream, Timers, Window};
-use nvx::host::artifacts::Artifacts;
+use nvx::host::artifacts::{Artifacts, absolute};
 use nvx::host::instance::generate_capability;
-use nvx::host::launch::LaunchSpec;
+use nvx::host::launch::{DEFAULT_MEMORY_MIB, LaunchSpec};
 use nvx::host::report;
 use nvx::host::session;
-use nvx::host::store::{IdentityPart, LaunchId, LockedStore, SandboxStore};
+use nvx::host::store::{IdentityPart, LOG_NAME, LaunchId, LockedStore, SandboxStore};
 use nvx::host::supervisor::{self, Reattached, Starting, StopOutcome, Vmm, VmmCommand};
+use nvx::host::template::{CAPTURES_NAME, Created, HostTime, Store, TRANSACTION_NAME};
 use nvx::protocol::CAPABILITY_LEN;
 use nvx::protocol::root::ImageFormat;
 use nvx::uuid::Uuid;
 use nvx::{ErrorKind, Hypervisor};
 use runtime_adapter::GUEST_BUILD;
+use runtime_adapter::capture::{
+    DEFAULT_CPU_PROFILE, DEFAULT_PROCESSORS, DEFAULT_SCRATCH_LENGTH, Request,
+};
 use runtime_adapter::exec::{self, AccountMode, HostExecution, Start};
 use runtime_adapter::frame::{MAX_BODY, Message};
 use runtime_adapter::hook::{Step, StepHook};
@@ -201,9 +236,20 @@ const SESSION_TIMEOUT: Duration = Duration::from_secs(30);
 const STOP_TIMEOUT: Duration = Duration::from_secs(30);
 /// How long a stop waits for a VM that it terminated to exit.
 const FORCED_TIMEOUT: Duration = Duration::from_secs(10);
-/// The name of the initramfs that boots the guest agent, which the launch writes into the
-/// sandbox's store.
+/// The name of the initramfs that boots the guest agent, which a launch writes into the sandbox's
+/// store, and a creation into a private directory of its own.
 const INITRAMFS_NAME: &str = "runtime-adapter.cpio.gz";
+/// How long a creation waits for the slot of the template's class and for the template store's
+/// lock, and for a capture, which boots the template's VM and writes its RAM.
+const CAPTURE_TIMEOUT: Duration = Duration::from_secs(120);
+/// The prefix of the name of the directory, private to the current user, into which a creation
+/// writes the initramfs of a capture's VM, in the system's temporary directory.
+const CAPTURE_DIRECTORY_PREFIX: &str = "runtime-adapter-template-";
+/// The hexadecimal digits of the identity of a capture class that name its slot in a template
+/// store, as the store documents its layout.
+const SLOT_NAME_LEN: usize = 16;
+/// Bytes in a mebibyte, the unit of `create`'s `--memory` and `--memory-capacity`.
+const MIB: u64 = 1024 * 1024;
 /// The exit status of a command that finds the VM mismatched.
 const MISMATCHED: u8 = 3;
 /// The exit status of a command whose guest reported that a stage of the root failed, once the VM
@@ -244,6 +290,12 @@ const USAGE: &str = concat!(
     "            [--workload-identity UID:GID] [--network FILE]\n",
     "            [--share HOST:TARGET[:ro]... [--deny PATH]... [--reserved TARGET]...",
     " [--share-root DIR]...]]\n",
+    "       runtime-adapter-host create STORE --guest-agent PATH --distro FORMAT:PATH",
+    " --distro-identity UUID\n",
+    "           [--hypervisor NAME] [--guest-build BUILD] [--cpu-profile PROFILE]",
+    " [--processors N]\n",
+    "           [--memory MIB] [--memory-capacity MIB] [--scratch-length BYTES]",
+    " [--network FILE]\n",
     "       runtime-adapter-host (reattach | stop) STORE [--guest-build BUILD]\n",
     "       runtime-adapter-host probe STORE PROBE... [--guest-build BUILD]\n",
     "       runtime-adapter-host exec STORE [--guest-build BUILD] EXECUTION [';' EXECUTION]...\n",
@@ -284,6 +336,19 @@ enum Command {
         /// The step hook, for tests, if `RUNTIME_ADAPTER_STEP_HOOK` sets one.
         hook: Option<StepHook>,
     },
+    /// Serve a template from a template store, which captures one if it holds none.
+    Create {
+        /// The template store.
+        store: PathBuf,
+        /// The guest agent's executable.
+        guest_agent: PathBuf,
+        /// The hypervisor, unless `nvx::Hypervisor::from_env_or_default` selects it.
+        hypervisor: Option<Hypervisor>,
+        /// The guest agent's build.
+        guest_build: String,
+        /// The template.
+        template: Box<Template>,
+    },
     /// Reattach to the VM, and stop it if asked.
     Reattach {
         /// The sandbox's store.
@@ -408,6 +473,28 @@ struct Layered {
     network: Option<PathBuf>,
 }
 
+/// The template of `create`, as its options give it.
+struct Template {
+    /// The placeholder.
+    distro: PathBuf,
+    /// The placeholder's format.
+    format: ImageFormat,
+    /// The identity that the guest would expect of the placeholder.
+    identity: Uuid,
+    /// The CPU profile.
+    cpu_profile: String,
+    /// The processors, all online at boot.
+    processors: u32,
+    /// The RAM, in bytes.
+    memory: u64,
+    /// The RAM capacity, in bytes.
+    memory_capacity: u64,
+    /// The length of the dormant scratch, in bytes.
+    scratch_length: u64,
+    /// The file of the template's network, if it has one.
+    network: Option<PathBuf>,
+}
+
 /// The options of a command.
 #[derive(Default)]
 struct Options {
@@ -437,6 +524,16 @@ struct Options {
     sharing: HostFsSharing,
     /// `--network`.
     network: Option<PathBuf>,
+    /// `--cpu-profile`.
+    cpu_profile: Option<String>,
+    /// `--processors`.
+    processors: Option<u32>,
+    /// `--memory`, in bytes.
+    memory: Option<u64>,
+    /// `--memory-capacity`, in bytes.
+    memory_capacity: Option<u64>,
+    /// `--scratch-length`.
+    scratch_length: Option<u64>,
 }
 
 fn main() -> ExitCode {
@@ -478,6 +575,13 @@ fn main() -> ExitCode {
             layered.as_deref(),
             hook.as_ref(),
         ),
+        Command::Create {
+            store,
+            guest_agent,
+            hypervisor,
+            guest_build,
+            template,
+        } => create(&store, &guest_agent, hypervisor, &guest_build, &template),
         Command::Reattach {
             store,
             guest_build,
@@ -508,16 +612,15 @@ fn parse(arguments: Vec<OsString>) -> Result<Command, String> {
         return Ok(Command::Report);
     };
     let name = match name.to_str() {
-        Some(name @ ("stage" | "launch" | "reattach" | "stop" | "probe" | "exec")) => {
+        Some(name @ ("stage" | "launch" | "create" | "reattach" | "stop" | "probe" | "exec")) => {
             name.to_owned()
         }
         _ => return Err(format!("unknown command {name:?}")),
     };
-    let store = PathBuf::from(
-        arguments
-            .next()
-            .ok_or_else(|| format!("{name} needs a sandbox store"))?,
-    );
+    let store = PathBuf::from(arguments.next().ok_or_else(|| match name.as_str() {
+        "create" => "create needs a template store".to_owned(),
+        _ => format!("{name} needs a sandbox store"),
+    })?);
     if name == "exec" {
         return parse_exec(store, arguments);
     }
@@ -623,6 +726,33 @@ fn parse(arguments: Vec<OsString>) -> Result<Command, String> {
                 hook: StepHook::from_env()?,
             }
         }
+        "create" => {
+            let guest_agent = options.guest_agent.ok_or("create needs --guest-agent")?;
+            let (format, distro) = options.distro.ok_or("create needs --distro")?;
+            let identity = options.identity.ok_or("create needs --distro-identity")?;
+            let memory = options
+                .memory
+                .unwrap_or(u64::from(DEFAULT_MEMORY_MIB) * MIB);
+            Command::Create {
+                store,
+                guest_agent,
+                hypervisor: options.hypervisor,
+                guest_build,
+                template: Box::new(Template {
+                    distro,
+                    format,
+                    identity,
+                    cpu_profile: options
+                        .cpu_profile
+                        .unwrap_or_else(|| DEFAULT_CPU_PROFILE.to_owned()),
+                    processors: options.processors.unwrap_or(DEFAULT_PROCESSORS),
+                    memory,
+                    memory_capacity: options.memory_capacity.unwrap_or(memory),
+                    scratch_length: options.scratch_length.unwrap_or(DEFAULT_SCRATCH_LENGTH),
+                    network: options.network,
+                }),
+            }
+        }
         "probe" if probes.is_empty() => return Err("probe needs a probe".to_owned()),
         "probe" => Command::Probe {
             store,
@@ -651,14 +781,14 @@ fn parse_option(
             .map_err(|value| format!("the value {value:?} of {option} is not Unicode"))
     };
     match (name, option) {
-        ("launch", "--guest-agent") if options.guest_agent.is_none() => {
+        ("launch" | "create", "--guest-agent") if options.guest_agent.is_none() => {
             options.guest_agent = Some(PathBuf::from(value));
         }
-        ("launch", "--hypervisor") if options.hypervisor.is_none() => {
+        ("launch" | "create", "--hypervisor") if options.hypervisor.is_none() => {
             let hypervisor = text(value)?.parse().map_err(|error| describe(&error))?;
             options.hypervisor = Some(hypervisor);
         }
-        ("launch" | "stage", "--distro") if options.distro.is_none() => {
+        ("launch" | "stage" | "create", "--distro") if options.distro.is_none() => {
             let value = text(value)?;
             let distro = value.split_once(':').and_then(|(format, path)| {
                 let format = ImageFormat::from_name(format)?;
@@ -668,7 +798,7 @@ fn parse_option(
                 format!("--distro takes FORMAT:PATH, with the format erofs or gpt, not {value:?}")
             })?);
         }
-        ("launch" | "stage", "--distro-identity") if options.identity.is_none() => {
+        ("launch" | "stage" | "create", "--distro-identity") if options.identity.is_none() => {
             let value = text(value)?;
             let identity = Uuid::parse(&value)
                 .ok_or_else(|| format!("--distro-identity takes a UUID, not {value:?}"))?;
@@ -735,9 +865,36 @@ fn parse_option(
         ("launch", "--deny") => options.sharing.add_denied(value),
         ("launch", "--reserved") => options.sharing.add_reserved(text(value)?),
         ("launch", "--share-root") => options.sharing.add_root(value),
-        ("launch", "--network") if options.network.is_none() => {
+        ("launch" | "create", "--network") if options.network.is_none() => {
             options.network = Some(PathBuf::from(value));
         }
+        ("create", "--cpu-profile") if options.cpu_profile.is_none() => {
+            options.cpu_profile = Some(text(value)?);
+        }
+        ("create", "--processors") if options.processors.is_none() => {
+            let value = text(value)?;
+            let processors = value
+                .parse::<u32>()
+                .ok()
+                .filter(|processors| *processors > 0);
+            options.processors =
+                Some(processors.ok_or_else(|| {
+                    format!("--processors takes a positive number, not {value:?}")
+                })?);
+        }
+        ("create", "--memory") if options.memory.is_none() => {
+            options.memory = Some(mebibytes(option, &text(value)?)?);
+        }
+        ("create", "--memory-capacity") if options.memory_capacity.is_none() => {
+            options.memory_capacity = Some(mebibytes(option, &text(value)?)?);
+        }
+        ("create", "--scratch-length") if options.scratch_length.is_none() => {
+            let value = text(value)?;
+            let length = value.parse::<u64>().ok().filter(|length| *length > 0);
+            options.scratch_length = Some(length.ok_or_else(|| {
+                format!("--scratch-length takes a positive number of bytes, not {value:?}")
+            })?);
+        }
         (_, "--guest-build") if name != "stage" && options.guest_build.is_none() => {
             options.guest_build = Some(text(value)?);
         }
@@ -872,6 +1029,17 @@ fn numbers<T>(value: &str, parse: impl Fn(&str) -> Option<T>) -> Option<Vec<T>>
     value.split(',').map(parse).collect()
 }
 
+/// Returns the bytes of `value`, the value of `option`, a positive number of mebibytes, or says why
+/// it is not one.
+fn mebibytes(option: &str, value: &str) -> Result<u64, String> {
+    value
+        .parse::<u64>()
+        .ok()
+        .filter(|mebibytes| *mebibytes > 0)
+        .and_then(|mebibytes| mebibytes.checked_mul(MIB))
+        .ok_or_else(|| format!("{option} takes a positive number of MiB, not {value:?}"))
+}
+
 /// Stages the image `distro`, in `format`, of which the guest expects `identity`, and the ext4
 /// scratch image `scratch`, if any, in the sandbox store `store`, which it creates if needed.
 fn stage(
@@ -1194,6 +1362,154 @@ fn echo_body() -> Vec<u8> {
     (0..=u8::MAX).cycle().take(MAX_BODY).collect()
 }
 
+/// Serves a template of the guest agent `guest_agent`, of the build `guest_build`, which
+/// `template` describes, on `hypervisor`, or else the one that
+/// `nvx::Hypervisor::from_env_or_default` selects, from the template store `store`, which it
+/// creates if needed: a generation of the template's class that the store holds, and that is
+/// eligible at the host's time, or one that a capture makes, which the store publishes.
+fn create(
+    store: &Path,
+    guest_agent: &Path,
+    hypervisor: Option<Hypervisor>,
+    guest_build: &str,
+    template: &Template,
+) -> Result<ExitCode, String> {
+    // A network that the plan refuses fails the creation before it needs NVX's artifacts or the
+    // store.
+    let network = template
+        .network
+        .as_deref()
+        .map(read_network)
+        .transpose()
+        .map_err(|error| describe(&error))?;
+    let hypervisor = match hypervisor {
+        Some(hypervisor) => hypervisor,
+        None => Hypervisor::from_env_or_default().map_err(|error| describe(&error))?,
+    };
+    let runtime = runtime(guest_build)?;
+    runtime
+        .artifacts
+        .probe()
+        .map_err(|error| describe(&error))?;
+    let request = Request {
+        distro: template.distro.clone(),
+        format: template.format,
+        identity: template.identity,
+        hypervisor,
+        cpu_profile: template.cpu_profile.clone(),
+        processors: template.processors,
+        memory: template.memory,
+        memory_capacity: template.memory_capacity,
+        scratch_length: template.scratch_length,
+        network,
+    };
+    // The placeholder is staged as `stage` stages an image: its explicit verification may hash it,
+    // which no capture does.
+    let staged = Staged::stage(&request.distro, request.format, request.identity, None)
+        .map_err(|error| describe(&error))?;
+    // The VM boots the initramfs from a directory that only the current user may access, as a
+    // launch's VM boots it from the sandbox's store, so that no one else may change it first.
+    let directory = TemporaryDirectory::new(CAPTURE_DIRECTORY_PREFIX)?;
+    let initramfs = directory.path().join(INITRAMFS_NAME);
+    initramfs::write(&runtime.artifacts.initrd, guest_agent, &initramfs)
+        .map_err(|error| format!("cannot write the initramfs of the guest agent: {error}"))?;
+    // The capture creates the dormant scratch in the store, on the file system of its directory,
+    // or, before the store exists, of its parent's.
+    let store = absolute(store).map_err(|error| describe(&error))?;
+    let scratch = match store.parent() {
+        Some(parent) if !store.is_dir() => parent.to_owned(),
+        _ => store.clone(),
+    };
+    let capture = request
+        .capture(
+            staged.distro.binding,
+            &runtime,
+            guest_build,
+            &initramfs,
+            &scratch,
+        )
+        .map_err(|error| describe(&error))?;
+    // A class that no capture takes fails before the store is created.
+    let class = capture.class.identity().map_err(|error| describe(&error))?;
+    let store = Store::create(&store).map_err(|error| describe(&error))?;
+    let created = store
+        .create_template(&capture, HostTime::now, Instant::now() + CAPTURE_TIMEOUT)
+        .map_err(|error| {
+            // The store names the slot of a class by the first digits of its identity, and keeps
+            // the log of the VMM of the class's latest capture there once the capture's launch
+            // has ended, and in the capture's transaction until then.
+            let slot = store
+                .dir()
+                .join(CAPTURES_NAME)
+                .join(&class.to_string()[..SLOT_NAME_LEN]);
+            let logs = [
+                slot.join(TRANSACTION_NAME).join(LOG_NAME),
+                slot.join(LOG_NAME),
+            ];
+            match logs.into_iter().find(|log| log.is_file()) {
+                Some(log) => format!(
+                    "{}; see the VMM's log of the class's latest capture {}",
+                    describe(&error),
+                    log.display()
+                ),
+                None => describe(&error),
+            }
+        })?;
+    let how = match &created {
+        Created::Existing(_) => "existing",
+        Created::Captured(_) => "captured",
+    };
+    let generation = created.generation();
+    println!("created={how}");
+    println!("generation={}", generation.generation());
+    println!("key={}", generation.key());
+    println!("class={}", generation.class());
+    Ok(ExitCode::SUCCESS)
+}
+
+/// A directory private to the current user, which a command creates in the system's temporary
+/// directory, with a name of its own, and removes with everything in it once it drops it, as
+/// `create` does with the initramfs of a capture's VM.
+struct TemporaryDirectory(PathBuf);
+
+impl TemporaryDirectory {
+    /// Creates a directory in the system's temporary directory, whose name starts with `prefix`,
+    /// then the process ID, and which nothing had, private to the current user as NVX makes the
+    /// directory of a sandbox store, with `SandboxStore::create`: no one else may create, change,
+    /// or replace a file in it.
+    fn new(prefix: &str) -> Result<Self, String> {
+        let parent = env::temp_dir();
+        let pid = std::process::id();
+        for attempt in 0..u32::MAX {
+            let path = parent.join(format!("{prefix}{pid}-{attempt}"));
+            match fs::symlink_metadata(&path) {
+                Ok(_) => continue,
+                Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+                Err(error) => return Err(format!("cannot open {}: {error}", path.display())),
+            }
+            // NVX refuses a directory that someone else created at the path meanwhile, unless it
+            // is private to the current user, as it refuses such a sandbox store.
+            SandboxStore::create(&path).map_err(|error| describe(&error))?;
+            return Ok(Self(path));
+        }
+        Err(format!(
+            "every name of a directory of {prefix}{pid}- is taken in {}",
+            parent.display()
+        ))
+    }
+
+    /// Returns the directory's path.
+    fn path(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl Drop for TemporaryDirectory {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+
 /// Reattaches to the VM of the sandbox store `store`, with the guest agent's build `guest_build`,
 /// attaches a session to it, and exchanges a `Ping`, then stops the VM if `stop` asks.
 fn reattach(store: &Path, guest_build: &str, stop: bool) -> Result<ExitCode, String> {
diff --git a/tests/runtime-adapter/src/capture.rs b/tests/runtime-adapter/src/capture.rs
new file mode 100644
index 000000000..d3e69bfa3
--- /dev/null
+++ b/tests/runtime-adapter/src/capture.rs
@@ -0,0 +1,200 @@
+//! The host program's captures of templates: VMs of the guest agent's [`template`](crate::template)
+//! mode, which NVX's template store captures through NVX's supervisor, and publishes as its
+//! generations, with `nvx::host::template::Store::create_template`, as `runtime-adapter-host
+//! create` asks.
+//!
+//! A [`Request`] holds what the host program's options choose of a template: its placeholder, the
+//! backend, the CPU profile, the processors, all online at boot, the RAM and its capacity, the
+//! length of the dormant scratch, and the network, if any. [`Request::capture`] returns NVX's
+//! `Capture` of it: the adapter's plan of the placeholder, which the host program plans as it
+//! plans an image, with the network, the placeholder's binding, which the host program stages as
+//! it stages an image, NVX's artifacts with the initramfs of the adapter's VMs, and the class of
+//! the capture, from which NVX's store takes the slot that serializes the captures of the class,
+//! and checks the template's compatibility key:
+//!
+//! - the runtime identity of the adapter's VMs, which [`crate::runtime`] gives, and the guest
+//!   agent's build, as `runtime-adapter-guest/BUILD`;
+//! - the backend and the CPU profile, as OpenVMM's `--hypervisor` and `--cpu-profile` take them;
+//! - the processors, all online at boot, and the RAM and its capacity;
+//! - the geometries of the placeholder and of the dormant scratch, as OpenVMM presents a sandbox
+//!   block device, which [`geometry`] gives;
+//! - the network, which the adapter's plan renders too, and no other invariant setting.
+//!
+//! The capture's VM boots NVX's kernel with the initramfs of the adapter's VMs, which puts the
+//! guest agent in place of NVX's agents; see [`crate::initramfs`]. NVX gives it the kernel command
+//! line `nvx_sandbox=1`, with which NVX's `/init` hands it to the guest agent's PID 1 of a layered
+//! root, and OpenVMM adds the platform tier's tokens, `nvx_snapshot_tier=platform` among them: the
+//! worker then captures the VM before it assembles any root, and the capture ends the VM.
+
+use std::path::{Path, PathBuf};
+
+use nvx::host::artifacts::Artifacts;
+use nvx::host::sandbox::distro::{DISTRO_POLICY_REVISION, DistroBinding};
+use nvx::host::sandbox::{SandboxNetwork, SandboxPlan};
+use nvx::host::store::ArtifactIdentity;
+use nvx::host::template::{BlockGeometry, Capture, CaptureClass, Invariants};
+use nvx::protocol::root::ImageFormat;
+use nvx::uuid::Uuid;
+use nvx::{Hypervisor, Result};
+
+use crate::layered::plan;
+use crate::runtime::Runtime;
+
+/// The CPU profile of a template, unless the host program names another: `auto`, which OpenVMM's
+/// `--cpu-profile` takes for the built-in profile of the host's CPU, and which OpenVMM also
+/// selects without the option.
+pub const DEFAULT_CPU_PROFILE: &str = "auto";
+
+/// The processors of a template, unless the host program names another number.
+pub const DEFAULT_PROCESSORS: u32 = 1;
+
+/// The length of a template's dormant scratch, in bytes, unless the host program names another:
+/// 64 MiB, the length of the scratch template that NVX's CI makes with the guest artifacts.
+pub const DEFAULT_SCRATCH_LENGTH: u64 = 64 << 20;
+
+/// The size of a logical block of a sandbox block device, as OpenVMM presents it, in bytes.
+pub const LOGICAL_BLOCK_SIZE: u32 = 512;
+
+/// The size of a physical block of a sandbox block device, as OpenVMM presents it on Windows, in
+/// bytes.
+#[cfg(windows)]
+const WINDOWS_PHYSICAL_BLOCK_SIZE: u32 = 4096;
+
+/// What the host program asks of a template.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Request {
+    /// The placeholder: the image whose length is the capacity of every clone's image, a trusted
+    /// artifact of the platform, which the host program stages before the capture.
+    pub distro: PathBuf,
+    /// The placeholder's format.
+    pub format: ImageFormat,
+    /// The identity that the guest would expect of the placeholder, which a template names nowhere
+    /// that a clone restores.
+    pub identity: Uuid,
+    /// The backend.
+    pub hypervisor: Hypervisor,
+    /// The CPU profile, as OpenVMM's `--cpu-profile` takes it: `auto`, `host`, or a profile ID.
+    pub cpu_profile: String,
+    /// The processors, all online at boot.
+    pub processors: u32,
+    /// The RAM at boot, in bytes.
+    pub memory: u64,
+    /// The RAM capacity, in bytes, to which a restore may expand the RAM.
+    pub memory_capacity: u64,
+    /// The length of the dormant scratch, in bytes.
+    pub scratch_length: u64,
+    /// The network of the template's fixed NIC, or `None` for a template without a NIC.
+    pub network: Option<SandboxNetwork>,
+}
+
+impl Request {
+    /// Returns the adapter's plan of the placeholder, over RAM, with the network: the plan that
+    /// the host program makes of an image that it stages, as `staged::Staged::stage` makes it,
+    /// with the placeholder's path absolute and normalized. Its upper is no part of the template,
+    /// whose capture attaches its dormant scratch in the upper's place.
+    ///
+    /// Fails as `staged::Staged::stage` plans an image: with
+    /// [`ErrorKind::Unsupported`](nvx::ErrorKind::Unsupported) for a path that is not Unicode, and
+    /// otherwise as `SandboxPlan::validated` does.
+    pub fn plan(&self) -> Result<SandboxPlan> {
+        let plan = plan(&self.distro, self.format, self.identity, None)?;
+        Ok(plan.with_network(self.network.clone()))
+    }
+
+    /// Returns NVX's capture of the template that this requests, with the placeholder's binding
+    /// `binding`, the runtime of the adapter's VMs `runtime`, with the guest agent's build
+    /// `guest_build`, and the initramfs `initramfs`, which puts that guest agent in place of NVX's
+    /// agents, and whose dormant scratch is on the file system of the directory `scratch`, the
+    /// template store's, as the [module documentation](self) describes.
+    ///
+    /// Fails as [`plan`](Self::plan) and [`geometry`] do, and with
+    /// [`ErrorKind::Unsupported`](nvx::ErrorKind::Unsupported) if the guest agent's build is not
+    /// part of an artifact identity. It checks nothing else of the class, which
+    /// `CaptureClass::check` checks.
+    pub fn capture(
+        &self,
+        binding: DistroBinding,
+        runtime: &Runtime,
+        guest_build: &str,
+        initramfs: &Path,
+        scratch: &Path,
+    ) -> Result<Capture> {
+        let adapter = self.plan()?;
+        let class = CaptureClass {
+            runtime: runtime.identity.clone(),
+            guest_build: ArtifactIdentity::new(format!("runtime-adapter-guest/{guest_build}"))?,
+            hypervisor: self.hypervisor,
+            cpu_profile: self.cpu_profile.clone(),
+            processors: self.processors,
+            boot_processors: self.processors,
+            memory: self.memory,
+            memory_capacity: self.memory_capacity,
+            distro: geometry(adapter.distro().path(), binding.image().length())?,
+            scratch: geometry(scratch, self.scratch_length)?,
+            network: self.network.clone(),
+            invariants: Invariants::new(),
+        };
+        Ok(Capture {
+            class,
+            adapter,
+            binding,
+            policy_revision: DISTRO_POLICY_REVISION,
+            artifacts: Artifacts::new(
+                &runtime.artifacts.openvmm,
+                &runtime.artifacts.kernel,
+                initramfs,
+            ),
+        })
+    }
+}
+
+/// Returns the geometry that OpenVMM presents for a sandbox block device of `length` bytes, whose
+/// file is `path`, or is in the directory `path`: logical blocks of [`LOGICAL_BLOCK_SIZE`] bytes,
+/// and physical blocks of the size that the file system prefers for I/O, `st_blksize`, on Linux,
+/// of 4096 bytes on Windows, and of a logical block elsewhere.
+///
+/// A file in a directory is on the directory's file system, whose preferred size the directory
+/// reports too, unless the file is a mount point.
+///
+/// Fails with [`ErrorKind::Io`](nvx::ErrorKind::Io) if the file's metadata cannot be read on
+/// Linux, and with [`ErrorKind::Unsupported`](nvx::ErrorKind::Unsupported) if its size does not
+/// fit 32 bits.
+pub fn geometry(path: &Path, length: u64) -> Result<BlockGeometry> {
+    Ok(BlockGeometry {
+        length,
+        logical_block_size: LOGICAL_BLOCK_SIZE,
+        physical_block_size: physical_block_size(path)?,
+    })
+}
+
+/// Returns the size of a physical block that OpenVMM presents for a sandbox block device whose
+/// file is, or is in, `path`: the file system's preferred size for I/O.
+#[cfg(target_os = "linux")]
+fn physical_block_size(path: &Path) -> Result<u32> {
+    use std::os::unix::fs::MetadataExt as _;
+
+    let metadata = std::fs::metadata(path).map_err(|error| {
+        nvx::Error::io(format!("cannot read the metadata of {}", path.display())).with_source(error)
+    })?;
+    u32::try_from(metadata.blksize()).map_err(|_| {
+        nvx::Error::unsupported(format!(
+            "the block size {} of {} does not fit 32 bits",
+            metadata.blksize(),
+            path.display()
+        ))
+    })
+}
+
+/// Returns the size of a physical block that OpenVMM presents for a sandbox block device on
+/// Windows.
+#[cfg(windows)]
+fn physical_block_size(_: &Path) -> Result<u32> {
+    Ok(WINDOWS_PHYSICAL_BLOCK_SIZE)
+}
+
+/// Returns the size of a physical block that OpenVMM presents for a sandbox block device on hosts
+/// other than Linux and Windows: a logical block.
+#[cfg(not(any(target_os = "linux", windows)))]
+fn physical_block_size(_: &Path) -> Result<u32> {
+    Ok(LOGICAL_BLOCK_SIZE)
+}
diff --git a/tests/runtime-adapter/src/lib.rs b/tests/runtime-adapter/src/lib.rs
index 85d6c345f..def09cf7a 100644
--- a/tests/runtime-adapter/src/lib.rs
+++ b/tests/runtime-adapter/src/lib.rs
@@ -9,7 +9,7 @@
 //!   messages about a layered [`root`], its [`probe`]s, and [`exec`]utions, and the kernel command
 //!   line and statuses of its [`template`] mode;
 //! - host-only, with the `host` feature: the host API too, and the host program, in the `host`,
-//!   `runtime`, `initramfs`, `staged`, `sharing`, `layered`, and `hook` modules and the
+//!   `runtime`, `initramfs`, `staged`, `sharing`, `layered`, `capture`, and `hook` modules and the
 //!   `runtime-adapter-host` binary;
 //! - guest-only, with the `guest` feature: the guest API too, and the guest agent, in the `guest`
 //!   and `worker` modules and the `runtime-adapter-guest` binary, a static
@@ -47,8 +47,12 @@
 //!
 //! A VM whose kernel command line names the platform snapshot tier is a template's, which the
 //! worker captures before it assembles any root, so that every clone of the snapshot attaches a
-//! root of its own, in [`template`] mode.
+//! root of its own, in [`template`] mode. The host program's `runtime-adapter-host create`
+//! captures such a VM through NVX's template store, which publishes the snapshot as a generation
+//! of a template, in the `capture` module.
 
+#[cfg(feature = "host")]
+pub mod capture;
 pub mod exec;
 pub mod frame;
 #[cfg(all(feature = "guest", target_os = "linux"))]
diff --git a/tests/runtime-adapter/src/template.rs b/tests/runtime-adapter/src/template.rs
index a60449c7e..14906297b 100644
--- a/tests/runtime-adapter/src/template.rs
+++ b/tests/runtime-adapter/src/template.rs
@@ -10,11 +10,12 @@
 //! with `nvx::protocol::cmdline::parameters`: a command line without that parameter boots cold,
 //! as before, whatever else it holds. A platform snapshot holds the platform's invariant
 //! configuration alone, which every clone shares, so with that parameter, `boot` refuses any
-//! parameter that [`is_platform_token`] does not accept: the platform tier's allowlist, the same
-//! as OpenVMM's capture of a platform snapshot allows. The kernel drops double quotes from a
-//! parameter, and hands what follows `--` to init rather than taking it as parameters, though init
-//! may still read it from `/proc/cmdline`, so `boot` also refuses a template's command line that
-//! holds either, as OpenVMM refuses them in the command line of a VM with a control console.
+//! parameter that [`is_platform_token`] does not accept: the platform tier's allowlist, OpenVMM's
+//! own, compiled from the excerpts of its sources that NVX's tests keep. The kernel drops double
+//! quotes from a parameter, and hands what follows `--` to init rather than taking it as
+//! parameters, though init may still read it from `/proc/cmdline`, so `boot` also refuses a
+//! template's command line that holds either, as OpenVMM refuses them in the command line of a VM
+//! with a control console.
 //!
 //! The worker of a template's VM, and with it the VM, ends with [`COMMAND_LINE_STATUS`] once
 //! `boot` refused its command line, with [`CAPTURE_STATUS_BASE`] plus the number of the stage of
@@ -22,44 +23,55 @@
 //! and with [`RESTORED_STATUS`] in a clone, which it does not repair yet. A committed capture ends
 //! the template's VM before the worker returns.
 
-use std::fmt;
+use std::{fmt, str};
 
 use nvx::protocol::cmdline::{self, Parameter};
 
+/// Returns whether `token`, a parameter of a kernel command line as the command line spells it,
+/// such as `nr_cpus=2`, is on the platform tier's allowlist: whether OpenVMM's capture of a
+/// platform snapshot admits it in the VM's kernel command line.
+///
+/// The allowlist holds `earlycon=xe9`, `console=hvc0`, `console=hvc1`, `reboot=t`, `panic=-1`,
+/// `nvx_sandbox=1`, `nvx_config=0xd0010000,65536`, [`PLATFORM_TIER`], and the control tty's token,
+/// `nvx_control_tty=hvc2`, whole, and the tokens that start with `nr_cpus=`, `maxcpus=`,
+/// `virtio_mmio.device=`, `virtnet_ip=`, `virtnet_mask=`, `virtnet_gw=`, `virtnet_dns=`,
+/// `virtnet_ip6=`, or `virtnet_gw6=`, whose values OpenVMM writes.
+///
+/// It is OpenVMM's own check, `platform_command_line_token_is_invariant` of
+/// `openvmm_helpers::snapshot::microvm`, compiled from the excerpts of OpenVMM's sources that
+/// `nvx-rs/tests/vectors/openvmm/` keeps, of the OpenVMM revision that NVX pins. NVX's tests check
+/// each token of a template's kernel command line with the same excerpts, and an ignored test of
+/// `nvx-rs/tests/openvmm_vectors.rs` compares them with the OpenVMM submodule. OpenVMM checks
+/// tokens as text, so a token that is not UTF-8 is not on the allowlist, and it compares names
+/// exactly, though the kernel takes a dash in a parameter's name for an underscore.
+pub fn is_platform_token(token: &[u8]) -> bool {
+    str::from_utf8(token).is_ok_and(openvmm::admits)
+}
+
+/// OpenVMM's allowlist of the kernel command-line tokens of its platform snapshot tier, compiled
+/// from the excerpts of its sources in `nvx-rs/tests/vectors/openvmm/`, unchanged.
+#[allow(unreachable_pub)]
+mod openvmm {
+    /// OpenVMM's `openvmm_defs` crate, of which the allowlist reads one constant.
+    mod openvmm_defs {
+        /// OpenVMM's `openvmm_defs::microvm`.
+        pub(super) mod microvm {
+            include!("../../../nvx-rs/tests/vectors/openvmm/microvm_control_tty_command_line.rs");
+        }
+    }
+
+    include!("../../../nvx-rs/tests/vectors/openvmm/platform_command_line_token_is_invariant.rs");
+
+    /// Returns whether OpenVMM's platform allowlist admits `token`.
+    pub(super) fn admits(token: &str) -> bool {
+        platform_command_line_token_is_invariant(token)
+    }
+}
+
 /// The parameter that names the platform snapshot tier, which OpenVMM adds to the kernel command
 /// line of a template's VM.
 pub const PLATFORM_TIER: &str = "nvx_snapshot_tier=platform";
 
-/// The tokens of the platform tier's allowlist that it names whole: the consoles, the reboot
-/// and panic settings, the sandbox's guest mode, NVX's configuration window, the tier itself, and
-/// the control tty.
-const PLATFORM_TOKENS: [&str; 9] = [
-    "earlycon=xe9",
-    "console=hvc0",
-    "console=hvc1",
-    "reboot=t",
-    "panic=-1",
-    "nvx_sandbox=1",
-    "nvx_config=0xd0010000,65536",
-    PLATFORM_TIER,
-    "nvx_control_tty=hvc2",
-];
-
-/// The prefixes of the platform tier's tokens whose values the host chooses: the processor
-/// capacity, the number of processors online at boot, the virtio-mmio devices, and the addresses
-/// of the VM's network, if it has one.
-const PLATFORM_PREFIXES: [&str; 9] = [
-    "nr_cpus=",
-    "maxcpus=",
-    "virtio_mmio.device=",
-    "virtnet_ip=",
-    "virtnet_mask=",
-    "virtnet_gw=",
-    "virtnet_dns=",
-    "virtnet_ip6=",
-    "virtnet_gw6=",
-];
-
 /// The status with which the worker of a template's VM, and with it the VM, ends once [`boot`]
 /// refused its kernel command line, or the worker could not read it.
 pub const COMMAND_LINE_STATUS: u8 = 20;
@@ -153,25 +165,6 @@ pub fn boot(command_line: &[u8]) -> Result<Boot, CommandLineError> {
     }
 }
 
-/// Returns whether `token`, a parameter of a kernel command line as the command line spells it,
-/// is one of the platform tier's: `earlycon=xe9`, `console=hvc0`, `console=hvc1`, `reboot=t`,
-/// `panic=-1`, `nvx_sandbox=1`, `nvx_config=0xd0010000,65536`, [`PLATFORM_TIER`], or
-/// `nvx_control_tty=hvc2`, or a token that starts with `nr_cpus=`, `maxcpus=`,
-/// `virtio_mmio.device=`, `virtnet_ip=`, `virtnet_mask=`, `virtnet_gw=`, `virtnet_dns=`,
-/// `virtnet_ip6=`, or `virtnet_gw6=`.
-///
-/// These are the tokens that OpenVMM's capture of a platform snapshot allows, byte for byte, so it
-/// compares names exactly, though the kernel takes a dash in a parameter's name for an
-/// underscore.
-pub fn is_platform_token(token: &[u8]) -> bool {
-    PLATFORM_TOKENS
-        .iter()
-        .any(|whole| token == whole.as_bytes())
-        || PLATFORM_PREFIXES
-            .iter()
-            .any(|prefix| token.starts_with(prefix.as_bytes()))
-}
-
 /// Returns `parameter` as the command line spells it, without quotes: its name, then `=` and its
 /// value, if it has one.
 fn token(parameter: &Parameter<'_>) -> Vec<u8> {
@@ -212,9 +205,24 @@ mod tests {
         ]
     }
 
+    /// The tokens that the platform tier's allowlist holds whole: the consoles, the reboot and
+    /// panic settings, the sandbox's guest mode, NVX's configuration window, the tier itself, and
+    /// the control tty.
+    const WHOLE: [&str; 9] = [
+        "earlycon=xe9",
+        "console=hvc0",
+        "console=hvc1",
+        "reboot=t",
+        "panic=-1",
+        "nvx_sandbox=1",
+        "nvx_config=0xd0010000,65536",
+        PLATFORM_TIER,
+        "nvx_control_tty=hvc2",
+    ];
+
     #[test]
     fn the_platform_tier_s_allowlist_is_openvmm_s() {
-        for token in PLATFORM_TOKENS {
+        for token in WHOLE {
             assert!(is_platform_token(token.as_bytes()), "{token}");
         }
         for token in [
@@ -281,6 +289,33 @@ mod tests {
         ] {
             assert!(!is_platform_token(token.as_bytes()), "{token}");
         }
+        // OpenVMM checks text: a token that is not UTF-8 is not on the allowlist, whatever it
+        // starts with.
+        for token in [
+            &b"virtnet_dns=10.0.2.3\xc2"[..],
+            b"nr_cpus=\xff",
+            b"\xff=\x01",
+        ] {
+            assert!(!is_platform_token(token), "{}", token.escape_ascii());
+        }
+    }
+
+    #[test]
+    fn the_platform_tier_s_allowlist_takes_tokens_as_openvmm_splits_them() {
+        // OpenVMM splits at ASCII whitespace alone, so it admits these tokens by their prefixes,
+        // but the kernel splits each in two at the vertical tab or at the no-break space's 0xa0,
+        // and its second parameter is not on the allowlist, so a template's VM refuses it.
+        for token in [
+            "virtnet_dns=10.0.2.3\u{0b}quiet",
+            "virtnet_dns=10.0.2.3\u{a0}quiet",
+        ] {
+            assert!(is_platform_token(token.as_bytes()), "{token:?}");
+            let names: Vec<&[u8]> = cmdline::parameters(token.as_bytes())
+                .map(|parameter| parameter.name)
+                .collect();
+            assert_eq!(names, [&b"virtnet_dns"[..], b"quiet"], "{token:?}");
+        }
+        assert!(!is_platform_token(b"quiet"));
     }
 
     #[test]
@@ -326,7 +361,7 @@ mod tests {
             // The tier alone, and each token whole once more, which OpenVMM leaves to its own
             // checks.
             format!("{PLATFORM_TIER}\n"),
-            format!("{} {}\n", TEMPLATE.trim_end(), PLATFORM_TOKENS.join(" ")),
+            format!("{} {}\n", TEMPLATE.trim_end(), WHOLE.join(" ")),
             // The kernel's whitespace: tabs, newlines, carriage returns, and no-break spaces.
             TEMPLATE.replace(' ', " \t\r\n\u{0b}\u{0c}"),
         ] {
@@ -397,18 +432,29 @@ mod tests {
         // The kernel's whitespace includes the vertical tab and the byte 0xa0, with which the
         // no-break space ends in UTF-8. A split at ASCII whitespace, as OpenVMM's checks of a
         // platform snapshot's command line make, keeps either within a token, but to the kernel,
-        // what follows either in a platform token's value is a parameter of its own.
-        for separator in ["\u{0b}", "\u{a0}"] {
+        // what follows either in a platform token's value is a parameter of its own. Before the
+        // no-break space's 0xa0, its first byte, 0xc2, stays in the platform token, which is then
+        // not text, and so not on the allowlist, which takes tokens as OpenVMM's text.
+        for (separator, refused) in [
+            ("\u{0b}", &b"quiet"[..]),
+            ("\u{a0}", b"virtnet_dns=10.0.2.3\xc2"),
+        ] {
             let command_line = format!(
                 "{} virtnet_dns=10.0.2.3{separator}quiet\n",
                 TEMPLATE.trim_end()
             );
             assert_eq!(
                 boot(command_line.as_bytes()),
-                Err(CommandLineError::Token(b"quiet".to_vec())),
+                Err(CommandLineError::Token(refused.to_vec())),
                 "{command_line:?}"
             );
         }
+        let mut latin1 = format!("{} virtnet_dns=10.0.2.3", TEMPLATE.trim_end()).into_bytes();
+        latin1.extend_from_slice(b"\xa0quiet\n");
+        assert_eq!(
+            boot(&latin1),
+            Err(CommandLineError::Token(b"quiet".to_vec()))
+        );
         assert_eq!(
             CommandLineError::Token(b"\xff=\x01".to_vec()).to_string(),
             "the kernel command line names the platform snapshot tier, but holds `\\xff=\\x01`, \
diff --git a/tests/runtime-adapter/tests/common/mod.rs b/tests/runtime-adapter/tests/common/mod.rs
index aeaf93096..061dd6c97 100644
--- a/tests/runtime-adapter/tests/common/mod.rs
+++ b/tests/runtime-adapter/tests/common/mod.rs
@@ -29,6 +29,7 @@ use nvx::host::artifacts::{ArtifactDir, Artifacts, Guest};
 use nvx::host::process::Process;
 use nvx::host::store::{LOG_NAME, RuntimeRecord, SandboxStore};
 use nvx::host::supervisor::{self, Reattached, StopOutcome};
+use nvx::host::template::{CAPTURES_NAME, Store, TRANSACTION_NAME};
 use runtime_adapter::layered::RECORD_NAME;
 use serde_json::Value;
 
@@ -52,6 +53,8 @@ pub(crate) type Printed = BTreeMap<String, String>;
 pub(crate) struct Fixtures {
     /// NVX's Ubuntu EROFS image.
     pub(crate) distro: PathBuf,
+    /// The image's manifest, beside it.
+    pub(crate) manifest: PathBuf,
     /// The image's UUID, from its manifest.
     pub(crate) identity: String,
     /// The scratch template.
@@ -77,23 +80,24 @@ impl Fixtures {
         ] {
             assert!(path.is_file(), "{fixture} is missing: {}", path.display());
         }
-        let manifest: Value = serde_json::from_str(&fs::read_to_string(&manifest).unwrap())
+        let contents: Value = serde_json::from_str(&fs::read_to_string(&manifest).unwrap())
             .expect("the manifest is JSON");
-        let identity = manifest["uuid"]
+        let identity = contents["uuid"]
             .as_str()
             .expect("the manifest holds the image's UUID")
             .to_owned();
         Self {
             distro,
+            manifest,
             identity,
             scratch,
         }
     }
 }
 
-/// A sandbox of a test: a directory of its own, which holds the sandbox's store, the output of
-/// each command of the host program that the test runs, and any file that the test makes for its
-/// VM.
+/// A sandbox of a test: a directory of its own, which holds the store of its commands, the output
+/// of each command of the host program that the test runs, and any file that the test makes for
+/// its VM.
 ///
 /// Dropping it ends a VM that a failed test left running, through its verified identity, and
 /// removes the directory once no VM of the sandbox runs. Should that remain uncertain, it keeps
@@ -101,7 +105,9 @@ impl Fixtures {
 pub(crate) struct Sandbox {
     /// The test's directory.
     pub(crate) root: PathBuf,
-    /// The sandbox's store, which the launch creates.
+    /// The store of the commands that the test runs: the sandbox's store, which the launch
+    /// creates, or a template store, which `create` creates, whose captures run their VMs in its
+    /// slots.
     pub(crate) store: PathBuf,
     /// The number of commands that the test ran.
     commands: usize,
@@ -174,22 +180,23 @@ impl Sandbox {
         options: &[&OsStr],
         environment: &[(&str, &OsStr)],
     ) -> Started {
-        let hypervisor = Hypervisor::from_env_or_default().expect("NVX_HYPERVISOR is valid");
-        let guest_agent = env::var_os(GUEST_AGENT).unwrap_or_else(|| {
-            panic!(
-                "{GUEST_AGENT} must name a static x86_64-unknown-linux-musl runtime-adapter-guest"
-            )
-        });
-        let mut arguments = vec![
-            OsStr::new("--guest-agent"),
-            &guest_agent,
-            OsStr::new("--hypervisor"),
-            OsStr::new(hypervisor.as_str()),
-        ];
+        let guest = guest_options();
+        let mut arguments: Vec<&OsStr> = guest.iter().map(OsString::as_os_str).collect();
         arguments.extend(options);
         self.start("launch", &arguments, environment)
     }
 
+    /// Creates a template of the guest agent in the sandbox's store, a template store, on the
+    /// hypervisor that `NVX_HYPERVISOR` selects, and with `options` too, checks that the creation
+    /// exits with `status`, and returns what it printed.
+    pub(crate) fn create(&mut self, options: &[&OsStr], status: i32) -> Printed {
+        let guest = guest_options();
+        let mut arguments: Vec<&OsStr> = guest.iter().map(OsString::as_os_str).collect();
+        arguments.extend(options);
+        let started = self.start("create", &arguments, &[]);
+        self.finish(started, status)
+    }
+
     /// Waits for the launch `started` to end, checks that it exits with `status`, and returns what
     /// it printed. A launch that succeeded recorded its VM, which runs.
     pub(crate) fn finish_launch(&self, started: Started, status: i32) -> Printed {
@@ -306,19 +313,38 @@ impl Sandbox {
     }
 
     /// Returns what the command whose output files start with `output` printed, and the end of the
-    /// VMM's log.
+    /// VMM's log, or of the log of each capture's VMM in a template store.
     fn diagnostics(&self, output: &Path) -> String {
         let read = |path: PathBuf| {
             let bytes = fs::read(path).unwrap_or_default();
             let tail = bytes.len().saturating_sub(LOG_TAIL);
             String::from_utf8_lossy(&bytes[tail..]).into_owned()
         };
-        format!(
+        let mut diagnostics = format!(
             "\nstdout:\n{}\nstderr:\n{}\nthe end of the VMM's log:\n{}",
             read(output.with_extension("out")),
             read(output.with_extension("err")),
             read(self.store.join(LOG_NAME)),
-        )
+        );
+        let slots = fs::read_dir(self.store.join(CAPTURES_NAME))
+            .into_iter()
+            .flatten();
+        for slot in slots.flatten() {
+            // The slot keeps the log of its latest capture once the capture's launch has ended,
+            // and until then the capture's transaction does.
+            let logs = [
+                slot.path().join(LOG_NAME),
+                slot.path().join(TRANSACTION_NAME).join(LOG_NAME),
+            ];
+            for log in logs.into_iter().filter(|log| log.exists()) {
+                diagnostics.push_str(&format!(
+                    "\nthe end of the capture's VMM's log {}:\n{}",
+                    log.display(),
+                    read(log.clone())
+                ));
+            }
+        }
+        diagnostics
     }
 
     /// Returns what the last command that the test ran wrote to its standard error.
@@ -356,12 +382,19 @@ impl Sandbox {
 
     /// Ends the VM that the sandbox's store records, whatever its runtime identity: reattach ends
     /// an interrupted launch, and holds a VM that runs, which the stop then terminates through its
-    /// verified identity. Fails with the reason why a VM of the sandbox might still run.
+    /// verified identity. In a template store, the store's recovery ends the captures that a
+    /// failed test interrupted, whose VMs run in its slots. Fails with the reason why a VM of the
+    /// sandbox might still run.
     fn end_vm(&self) -> Result<(), String> {
         if !self.store.exists() {
             return Ok(());
         }
         let failed = |error: nvx::Error| describe(&error);
+        if self.store.join(CAPTURES_NAME).is_dir() {
+            let store = Store::open(&self.store).map_err(failed)?;
+            let deadline = Instant::now() + Duration::from_secs(30);
+            return store.recover_captures(deadline).map(drop).map_err(failed);
+        }
         let store = SandboxStore::open(&self.store).map_err(failed)?;
         let recorded = (
             store.runtime().map_err(failed)?,
@@ -421,6 +454,21 @@ pub(crate) fn describe(error: &dyn Error) -> String {
     description
 }
 
+/// Returns the options of a launch or a creation that name the guest agent, which
+/// `RUNTIME_ADAPTER_GUEST` names, and the hypervisor that `NVX_HYPERVISOR` selects.
+fn guest_options() -> [OsString; 4] {
+    let hypervisor = Hypervisor::from_env_or_default().expect("NVX_HYPERVISOR is valid");
+    let guest_agent = env::var_os(GUEST_AGENT).unwrap_or_else(|| {
+        panic!("{GUEST_AGENT} must name a static x86_64-unknown-linux-musl runtime-adapter-guest")
+    });
+    [
+        OsString::from("--guest-agent"),
+        guest_agent,
+        OsString::from("--hypervisor"),
+        OsString::from(hypervisor.as_str()),
+    ]
+}
+
 /// Returns the epoch that a command printed.
 pub(crate) fn epoch(printed: &Printed) -> u64 {
     printed["epoch"].parse().unwrap()
diff --git a/tests/runtime-adapter/tests/layered_launch.rs b/tests/runtime-adapter/tests/layered_launch.rs
index e726a2d74..2103523c6 100644
--- a/tests/runtime-adapter/tests/layered_launch.rs
+++ b/tests/runtime-adapter/tests/layered_launch.rs
@@ -1776,6 +1776,127 @@ fn the_host_program_refuses_options_that_do_not_make_a_command() {
             .iter()
             .map(|(options, problem)| ([&stage[..], options].concat(), *problem)),
     );
+    let create = [
+        "create",
+        "templates",
+        "--guest-agent",
+        "agent",
+        "--distro",
+        "erofs:image",
+        "--distro-identity",
+        uuid,
+    ];
+    let create_cases: [(&[&str], &str); 16] = [
+        (
+            &["--processors", "0"],
+            "--processors takes a positive number, not \"0\"",
+        ),
+        (
+            &["--processors", "two"],
+            "--processors takes a positive number, not \"two\"",
+        ),
+        (
+            &["--memory", "0"],
+            "--memory takes a positive number of MiB, not \"0\"",
+        ),
+        (
+            &["--memory", "256M"],
+            "--memory takes a positive number of MiB, not \"256M\"",
+        ),
+        // A number of mebibytes whose bytes do not fit 64 bits.
+        (
+            &["--memory-capacity", "17592186044416"],
+            "--memory-capacity takes a positive number of MiB, not \"17592186044416\"",
+        ),
+        (
+            &["--scratch-length", "0"],
+            "--scratch-length takes a positive number of bytes, not \"0\"",
+        ),
+        (
+            &["--scratch-length", "64M"],
+            "--scratch-length takes a positive number of bytes, not \"64M\"",
+        ),
+        (
+            &["--cpu-profile", "auto", "--cpu-profile", "host"],
+            "unexpected option \"--cpu-profile\" of create",
+        ),
+        (
+            &["--upper", "ram"],
+            "unexpected option \"--upper\" of create",
+        ),
+        (
+            &["--runtime-dir", "/run/a"],
+            "unexpected option \"--runtime-dir\" of create",
+        ),
+        (
+            &["--workload-identity", "1000:1000"],
+            "unexpected option \"--workload-identity\" of create",
+        ),
+        (
+            &["--share", "a:/b"],
+            "unexpected option \"--share\" of create",
+        ),
+        (
+            &["--first-partition-bound", "4096"],
+            "unexpected option \"--first-partition-bound\" of create",
+        ),
+        (
+            &["--distro", "gpt:image"],
+            "unexpected option \"--distro\" of create",
+        ),
+        (&["--network"], "\"--network\" needs a value"),
+        (&["image"], "unexpected argument \"image\" of create"),
+    ];
+    commands.extend(
+        create_cases
+            .iter()
+            .map(|(options, problem)| ([&create[..], options].concat(), *problem)),
+    );
+    commands.extend([
+        (vec!["create"], "create needs a template store"),
+        (vec!["create", "templates"], "create needs --guest-agent"),
+        (
+            vec!["create", "templates", "--guest-agent", "agent"],
+            "create needs --distro",
+        ),
+        (
+            vec![
+                "create",
+                "templates",
+                "--guest-agent",
+                "agent",
+                "--distro",
+                "erofs:image",
+            ],
+            "create needs --distro-identity",
+        ),
+        (
+            vec![
+                "launch",
+                "store",
+                "--guest-agent",
+                "agent",
+                "--cpu-profile",
+                "host",
+            ],
+            "unexpected option \"--cpu-profile\" of launch",
+        ),
+        (
+            vec![
+                "launch",
+                "store",
+                "--guest-agent",
+                "agent",
+                "--processors",
+                "2",
+            ],
+            "unexpected option \"--processors\" of launch",
+        ),
+        (
+            vec!["stage", "store", "--memory", "256"],
+            "unexpected option \"--memory\" of stage",
+        ),
+    ]);
     commands.extend([
         (vec!["stage"], "stage needs a sandbox store"),
         (vec!["stage", "store"], "stage needs --distro"),
diff --git a/tests/runtime-adapter/tests/template_capture.rs b/tests/runtime-adapter/tests/template_capture.rs
new file mode 100644
index 000000000..c5ea68f5c
--- /dev/null
+++ b/tests/runtime-adapter/tests/template_capture.rs
@@ -0,0 +1,269 @@
+//! The host program's captures of templates, without a hypervisor: the capture that
+//! `runtime_adapter::capture` makes of what the host program asks of a template, with its class,
+//! and the creations that the host program refuses before it creates anything. The VM tests of
+//! `tests/vm_template.rs` capture templates on a real hypervisor.
+#![cfg(feature = "host")]
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Output};
+
+use nvx::Hypervisor;
+use nvx::host::artifacts::Artifacts;
+use nvx::host::sandbox::SandboxNetwork;
+use nvx::host::sandbox::distro::DISTRO_POLICY_REVISION;
+use nvx::host::store::{ArtifactIdentity, RuntimeIdentity};
+use nvx::protocol::root::{ImageFormat, RootImage};
+use nvx::uuid::Uuid;
+use runtime_adapter::capture::{
+    DEFAULT_CPU_PROFILE, DEFAULT_PROCESSORS, DEFAULT_SCRATCH_LENGTH, LOGICAL_BLOCK_SIZE, Request,
+    geometry,
+};
+use runtime_adapter::layered::read_network;
+use runtime_adapter::runtime::Runtime;
+use runtime_adapter::staged::Staged;
+use serde_json::{Value, json};
+
+/// Bytes in a mebibyte.
+const MIB: u64 = 1024 * 1024;
+
+/// Returns a directory of the test `name`, empty, below Cargo's temporary directory.
+fn directory(name: &str) -> PathBuf {
+    let directory = Path::new(env!("CARGO_TARGET_TMPDIR")).join(name);
+    let _ = fs::remove_dir_all(&directory);
+    fs::create_dir_all(&directory).unwrap();
+    directory
+}
+
+/// Returns the identity that the tests give their placeholders.
+fn identity() -> Uuid {
+    Uuid::parse("0a490905-41be-ed5f-984e-63eb7e5e20b1").unwrap()
+}
+
+/// Returns the serde form of a network with egress allowed, and ingress and host-loopback access
+/// denied, which a template takes.
+fn egress_network() -> Value {
+    json!({
+        "guestNetwork": "192.0.2.2/24",
+        "egress": "allow",
+        "allow": {"name": "egress.allow", "rules": []},
+        "deny": {"name": "egress.deny", "rules": []},
+        "ingress": "deny",
+        "hostLoopback": "deny",
+        "hostLoopbackForwards": [],
+        "proxy": null,
+    })
+}
+
+/// Returns the runtime of NVX's artifacts in `directory`, which the tests never boot, with the
+/// runtime identity of the adapter's VMs.
+fn runtime(directory: &Path) -> Runtime {
+    let identity = |text: &str| ArtifactIdentity::new(text).unwrap();
+    Runtime {
+        artifacts: Artifacts::new(
+            directory.join("openvmm"),
+            directory.join("vmlinux"),
+            directory.join("initramfs.cpio.gz"),
+        ),
+        identity: RuntimeIdentity::new(
+            identity("sha256:openvmm"),
+            identity("sha256:kernel"),
+            identity("sha256:initramfs+runtime-adapter-guest/build"),
+        ),
+    }
+}
+
+/// Returns the request of a template of the placeholder `distro`, with the host program's defaults
+/// and `network`.
+fn template(distro: &Path, network: Option<SandboxNetwork>) -> Request {
+    Request {
+        distro: distro.to_owned(),
+        format: ImageFormat::Erofs,
+        identity: identity(),
+        hypervisor: Hypervisor::Kvm,
+        cpu_profile: DEFAULT_CPU_PROFILE.to_owned(),
+        processors: DEFAULT_PROCESSORS,
+        memory: 256 * MIB,
+        memory_capacity: 256 * MIB,
+        scratch_length: DEFAULT_SCRATCH_LENGTH,
+        network,
+    }
+}
+
+/// Returns the physical block size that OpenVMM presents for a sandbox block device whose file is,
+/// or is in, `path` on this host: the file system's preferred size for I/O on Linux, and 4096 on
+/// Windows.
+fn physical_block_size(path: &Path) -> u32 {
+    #[cfg(target_os = "linux")]
+    {
+        use std::os::unix::fs::MetadataExt as _;
+        u32::try_from(fs::metadata(path).unwrap().blksize()).unwrap()
+    }
+    #[cfg(windows)]
+    {
+        let _ = path;
+        4096
+    }
+    #[cfg(not(any(target_os = "linux", windows)))]
+    {
+        let _ = path;
+        LOGICAL_BLOCK_SIZE
+    }
+}
+
+#[test]
+fn a_capture_takes_its_class_and_inputs_from_the_request() {
+    let directory = directory("template-capture-request");
+    let distro = directory.join("placeholder.erofs");
+    fs::write(&distro, vec![0; 2 * MIB as usize]).unwrap();
+    let runtime = runtime(&directory);
+    let initramfs = directory.join("template.cpio.gz");
+    let network: SandboxNetwork = serde_json::from_value(egress_network()).unwrap();
+    let request = template(&distro, Some(network.clone()));
+    let staged = Staged::stage(&distro, ImageFormat::Erofs, identity(), None).unwrap();
+    let capture = request
+        .capture(
+            staged.distro.binding.clone(),
+            &runtime,
+            "build",
+            &initramfs,
+            &directory,
+        )
+        .unwrap();
+
+    // The adapter's plan of the placeholder, as the host program stages it, with the network,
+    // over RAM, which no template keeps.
+    let adapter = &capture.adapter;
+    assert_eq!(adapter.distro().path(), staged.distro.path);
+    assert_eq!(
+        adapter.distro().image(),
+        RootImage {
+            format: ImageFormat::Erofs,
+            identity: Some(identity()),
+        }
+    );
+    assert_eq!(adapter.upper().scratch_path(), None);
+    assert!(adapter.settings().is_none());
+    assert_eq!(adapter.network(), Some(&network));
+    assert_eq!(capture.binding, staged.distro.binding);
+    assert_eq!(capture.policy_revision, DISTRO_POLICY_REVISION);
+    assert_eq!(capture.artifacts.openvmm, runtime.artifacts.openvmm);
+    assert_eq!(capture.artifacts.kernel, runtime.artifacts.kernel);
+    assert_eq!(capture.artifacts.initrd, initramfs);
+
+    // The class: the runtime, the guest agent's build, the machine that the request asks for,
+    // with every processor online at boot, the geometries that OpenVMM presents, and the network.
+    let class = &capture.class;
+    assert_eq!(class.runtime, runtime.identity);
+    assert_eq!(class.guest_build.as_str(), "runtime-adapter-guest/build");
+    assert_eq!(class.hypervisor, Hypervisor::Kvm);
+    assert_eq!(class.cpu_profile, "auto");
+    assert_eq!((class.processors, class.boot_processors), (1, 1));
+    assert_eq!(
+        (class.memory, class.memory_capacity),
+        (256 * MIB, 256 * MIB)
+    );
+    assert_eq!(class.distro.length, 2 * MIB);
+    assert_eq!(class.distro.logical_block_size, LOGICAL_BLOCK_SIZE);
+    assert_eq!(
+        class.distro.physical_block_size,
+        physical_block_size(&distro)
+    );
+    assert_eq!(class.scratch.length, 64 * MIB);
+    assert_eq!(class.scratch.logical_block_size, LOGICAL_BLOCK_SIZE);
+    assert_eq!(
+        class.scratch.physical_block_size,
+        physical_block_size(&directory)
+    );
+    assert_eq!(class.network.as_ref(), Some(&network));
+    assert!(class.invariants.is_empty());
+    let with_nic = class.identity().unwrap();
+
+    // Every processor is online at boot, whatever the request's number, and the network names
+    // the class: one without a network is another.
+    let mut more = template(&distro, None);
+    more.processors = 4;
+    more.memory_capacity = 512 * MIB;
+    let capture = more
+        .capture(
+            staged.distro.binding,
+            &runtime,
+            "build",
+            &initramfs,
+            &directory,
+        )
+        .unwrap();
+    assert_eq!(
+        (capture.class.processors, capture.class.boot_processors),
+        (4, 4)
+    );
+    assert_eq!(capture.class.memory_capacity, 512 * MIB);
+    assert_eq!(capture.adapter.network(), None);
+    assert_eq!(capture.class.network, None);
+    assert_ne!(capture.class.identity().unwrap(), with_nic);
+
+    // OpenVMM presents logical blocks of 512 bytes.
+    let presented = geometry(&distro, 4096).unwrap();
+    assert_eq!(presented.length, 4096);
+    assert_eq!(presented.logical_block_size, 512);
+    assert!(presented.physical_block_size >= 512);
+    assert!(presented.physical_block_size.is_power_of_two());
+}
+
+#[test]
+fn the_host_program_refuses_a_template_before_it_creates_anything() {
+    let directory = directory("template-capture-command");
+    let distro = directory.join("placeholder.erofs");
+    fs::write(&distro, vec![0; 4096]).unwrap();
+    let store = directory.join("templates");
+    // Without NVX's artifacts, a creation fails once it has read its network.
+    let create = |network: Option<&Path>| -> Output {
+        let mut image = std::ffi::OsString::from("erofs:");
+        image.push(&distro);
+        let mut command = Command::new(env!("CARGO_BIN_EXE_runtime-adapter-host"));
+        command
+            .arg("create")
+            .arg(&store)
+            .args(["--guest-agent", "agent", "--hypervisor", "kvm", "--distro"])
+            .arg(image)
+            .args(["--distro-identity", &identity().to_string()]);
+        if let Some(network) = network {
+            command.arg("--network").arg(network);
+        }
+        command.env_remove(Artifacts::ENV_DIR).output().unwrap()
+    };
+    let failed = |output: Output| {
+        assert_eq!(output.status.code(), Some(1), "{output:?}");
+        // Nothing was created: not even the store.
+        assert!(!store.exists(), "{output:?}");
+        String::from_utf8_lossy(&output.stderr).into_owned()
+    };
+
+    // A network that the plan refuses, and one that cannot be read, fail the creation first.
+    let network = directory.join("network.json");
+    let mut proxy = egress_network();
+    proxy["proxy"] = json!({"port": 3128, "scheme": "http"});
+    fs::write(&network, proxy.to_string()).unwrap();
+    let stderr = failed(create(Some(&network)));
+    let refused = format!(
+        "the network {} is refused: a network proxy needs egress denied by default",
+        network.display()
+    );
+    assert!(stderr.contains(&refused), "{stderr}");
+    let missing = directory.join("missing.json");
+    let stderr = failed(create(Some(&missing)));
+    let unreadable = format!("cannot read the network {}", missing.display());
+    assert!(stderr.contains(&unreadable), "{stderr}");
+
+    // A network that the plan takes passes, as does no network, and the creation goes on to
+    // need NVX's artifacts.
+    fs::write(&network, egress_network().to_string()).unwrap();
+    read_network(&network).unwrap();
+    for network in [Some(network.as_path()), None] {
+        let stderr = failed(create(network));
+        assert!(
+            stderr.contains(&format!("set {} to NVX's artifacts", Artifacts::ENV_DIR)),
+            "{stderr}"
+        );
+    }
+}
diff --git a/tests/runtime-adapter/tests/vm_template.rs b/tests/runtime-adapter/tests/vm_template.rs
new file mode 100644
index 000000000..1dcd04157
--- /dev/null
+++ b/tests/runtime-adapter/tests/vm_template.rs
@@ -0,0 +1,530 @@
+//! The host program captures templates on a real hypervisor, through public APIs only: VMs of the
+//! guest agent's template mode, which NVX's template store captures through NVX's supervisor and
+//! publishes as its generations, as `runtime-adapter-host create` asks.
+//!
+//! Each scenario stages the placeholder of its templates, a copy of the fixtures' Ubuntu EROFS
+//! image with its manifest, as a platform stages its trusted artifacts, and creates a [`Template`]
+//! of it, with a [`Network`], or without one, in a template store of its own. A template that the
+//! store captured is the store's one generation, whose payload holds the record of its capture,
+//! its key, and its snapshot, and whose key holds what the scenario asked for: the runtime of the
+//! adapter's VMs, with the guest agent's build, the backend, the processors, all online at boot,
+//! the RAM and its capacity, the geometries of the placeholder and of the dormant scratch, a NIC
+//! exactly when the network lets something through, and a kernel command line of the platform
+//! tier's tokens alone, which names neither the placeholder's identity nor a root. The slot of the
+//! template's class then holds no transaction, and records no launch, and a second creation serves
+//! the generation without a capture. NVX refuses a network whose policy no template takes before
+//! any VM starts, and the host program refuses a class that no capture takes before it creates the
+//! store.
+//!
+//! The tests boot VMs, so they are ignored. They read what the `common` module lists, and take the
+//! placeholder from its fixtures.
+//!
+//! ```text
+//! cargo test --locked --features host --test vm_template -- --ignored
+//! ```
+#![cfg(feature = "host")]
+
+mod common;
+
+use std::env;
+use std::ffi::{OsStr, OsString};
+use std::fs::{self, File};
+use std::io;
+use std::path::{Path, PathBuf};
+
+use nvx::Hypervisor;
+use nvx::host::artifacts::Artifacts;
+use nvx::host::store::{LOG_NAME, SandboxStore};
+use nvx::host::template::{
+    CAPTURE_RECORD_NAME, CAPTURES_NAME, GENERATIONS_NAME, KEY_NAME, MANIFEST_NAME,
+    MEMORY_BLOCK_SIZE, SNAPSHOT_NAME, Store, TRANSACTION_NAME,
+};
+use nvx::protocol::cmdline::{self, Parameter};
+use runtime_adapter::GUEST_BUILD;
+use runtime_adapter::capture::{DEFAULT_SCRATCH_LENGTH, LOGICAL_BLOCK_SIZE};
+use runtime_adapter::runtime::Runtime;
+use runtime_adapter::template::is_platform_token;
+use serde_json::{Value, json};
+
+use common::{Fixtures, Printed, Sandbox};
+
+/// The exit status of the host program's command that failed, after a diagnostic.
+const FAILED: i32 = 1;
+/// Bytes in a mebibyte.
+const MIB: u64 = 1024 * 1024;
+/// The RAM of a template, unless the scenario names another, and its capacity, which the host
+/// program gives one by default: NVX's default memory, 256 MiB.
+const DEFAULT_MEMORY: u64 = 256 * MIB;
+/// The hexadecimal digits of the identity of a capture class that name its slot in a template
+/// store.
+const SLOT_NAME_LEN: usize = 16;
+/// The guest's address in the scenarios' networks, in a range reserved for documentation.
+const GUEST_NETWORK: &str = "192.0.2.2/24";
+/// The guest's gateway in the scenarios' networks.
+const GATEWAY: &str = "192.0.2.1";
+/// The port of host loopback at which a proxy-only network names its proxy. The capture opens no
+/// connection, so nothing listens there.
+const PROXY_PORT: u16 = 3128;
+/// The port of the gateway to which the allow rule lets TCP through.
+const RULE_PORT: u16 = 8080;
+
+/// The network of a scenario's template, which the creation reads from a file that the test
+/// writes, in the serde form of a plan's network: the guest at [`GUEST_NETWORK`], with egress
+/// denied and no host-loopback access unless the network says otherwise.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Network {
+    /// No network, which attaches no network device.
+    None,
+    /// Everything denied, without a proxy, which attaches no network device either.
+    Deny,
+    /// Egress allowed, without host-loopback access.
+    Egress,
+    /// Egress denied but for one rule, TCP to the gateway at [`RULE_PORT`], with outbound
+    /// host-loopback access.
+    AllowRule,
+    /// Egress allowed, with outbound host-loopback access.
+    Outbound,
+    /// A proxy-only network, whose proxy is at [`PROXY_PORT`] of host loopback.
+    Proxy,
+    /// Ingress allowed, which no template takes: OpenVMM would publish the guest's listeners.
+    Ingress,
+    /// Host-loopback access in both directions, which no template takes either.
+    HostLoopback,
+}
+
+impl Network {
+    /// Returns the network's serde form, or `None` without a network.
+    fn form(self) -> Option<Value> {
+        let mut form = json!({
+            "guestNetwork": GUEST_NETWORK,
+            "egress": "deny",
+            "allow": {"name": "egress.allow", "rules": []},
+            "deny": {"name": "egress.deny", "rules": []},
+            "ingress": "deny",
+            "hostLoopback": "deny",
+            "hostLoopbackForwards": [],
+            "proxy": null,
+        });
+        match self {
+            Self::None => return None,
+            Self::Deny => {}
+            Self::Egress => form["egress"] = json!("allow"),
+            Self::AllowRule => {
+                form["allow"]["rules"] = json!([{
+                    "to": [{"cidr": format!("{GATEWAY}/32"), "except": []}],
+                    "ports": [{"protocol": "tcp", "port": RULE_PORT, "endPort": null}],
+                }]);
+                form["hostLoopback"] = json!("outbound");
+            }
+            Self::Outbound => {
+                form["egress"] = json!("allow");
+                form["hostLoopback"] = json!("outbound");
+            }
+            Self::Proxy => form["proxy"] = json!({"port": PROXY_PORT, "scheme": "http"}),
+            Self::Ingress => form["ingress"] = json!("allow"),
+            Self::HostLoopback => form["hostLoopback"] = json!("allow"),
+        }
+        Some(form)
+    }
+
+    /// Returns whether the template has a NIC: whether the network lets anything through, for
+    /// which OpenVMM attaches a network device.
+    fn has_nic(self) -> bool {
+        !matches!(self, Self::None | Self::Deny)
+    }
+}
+
+/// A template that a scenario creates: its network, and the processors, the RAM, the RAM
+/// capacity, and the length of the dormant scratch that the creation names, or else the host
+/// program's defaults.
+#[derive(Clone, Copy, Debug)]
+struct Template {
+    /// The network.
+    network: Network,
+    /// The processors, all online at boot, or 1 by default.
+    processors: Option<u32>,
+    /// The RAM, in bytes, or [`DEFAULT_MEMORY`] by default.
+    memory: Option<u64>,
+    /// The RAM capacity, in bytes, or the RAM by default.
+    memory_capacity: Option<u64>,
+    /// The length of the dormant scratch, in bytes, or [`DEFAULT_SCRATCH_LENGTH`] by default.
+    scratch_length: Option<u64>,
+}
+
+impl Template {
+    /// Returns the template of `network`, with the host program's defaults.
+    fn new(network: Network) -> Self {
+        Self {
+            network,
+            processors: None,
+            memory: None,
+            memory_capacity: None,
+            scratch_length: None,
+        }
+    }
+
+    /// Returns the processors of the template.
+    fn processors(&self) -> u32 {
+        self.processors.unwrap_or(1)
+    }
+
+    /// Returns the RAM of the template, in bytes.
+    fn memory(&self) -> u64 {
+        self.memory.unwrap_or(DEFAULT_MEMORY)
+    }
+
+    /// Returns the RAM capacity of the template, in bytes.
+    fn memory_capacity(&self) -> u64 {
+        self.memory_capacity.unwrap_or(self.memory())
+    }
+
+    /// Returns the length of the template's dormant scratch, in bytes.
+    fn scratch_length(&self) -> u64 {
+        self.scratch_length.unwrap_or(DEFAULT_SCRATCH_LENGTH)
+    }
+}
+
+/// The template store of a test, in a sandbox of its own, which is the store of the test's
+/// commands, and the placeholder of its templates.
+struct Templates {
+    /// The test's sandbox.
+    sandbox: Sandbox,
+    /// The placeholder.
+    placeholder: PathBuf,
+    /// The identity that a guest would expect of the placeholder.
+    identity: String,
+}
+
+impl Templates {
+    /// Creates the sandbox of the test `name`, whose template store is `store` in it, and stages
+    /// the placeholder.
+    ///
+    /// On Linux, the control socket of a capture's VM, `captures/C/transaction/control.sock` in
+    /// the store, must fit the path of a Unix socket, so the tests' names and stores are short.
+    fn new(name: &str) -> Self {
+        let mut sandbox = Sandbox::new(name);
+        sandbox.store = sandbox.root.join("store");
+        let fixtures = Fixtures::find();
+        let placeholder = stage(&sandbox.root.join("platform"), &fixtures);
+        Self {
+            sandbox,
+            placeholder,
+            identity: fixtures.identity,
+        }
+    }
+
+    /// Creates `template` in the store, checks that the creation exits with `status`, and returns
+    /// what it printed.
+    fn create(&mut self, template: &Template, status: i32) -> Printed {
+        let mut distro = OsString::from("erofs:");
+        distro.push(&self.placeholder);
+        let mut options = vec![
+            OsString::from("--distro"),
+            distro,
+            OsString::from("--distro-identity"),
+            OsString::from(&self.identity),
+        ];
+        let numbers = [
+            ("--processors", template.processors.map(u64::from)),
+            ("--memory", template.memory.map(|memory| memory / MIB)),
+            (
+                "--memory-capacity",
+                template.memory_capacity.map(|capacity| capacity / MIB),
+            ),
+            ("--scratch-length", template.scratch_length),
+        ];
+        for (option, value) in numbers {
+            if let Some(value) = value {
+                options.extend([OsString::from(option), OsString::from(value.to_string())]);
+            }
+        }
+        if let Some(form) = template.network.form() {
+            let file = self.sandbox.root.join("network.json");
+            fs::write(&file, form.to_string()).unwrap();
+            options.extend([OsString::from("--network"), file.into_os_string()]);
+        }
+        let options: Vec<&OsStr> = options.iter().map(OsString::as_os_str).collect();
+        self.sandbox.create(&options, status)
+    }
+
+    /// Returns the template store, which a creation created.
+    fn store(&self) -> Store {
+        Store::open(&self.sandbox.store).unwrap()
+    }
+
+    /// Returns the slot of the class whose identity `class` printed.
+    fn slot(&self, class: &str) -> PathBuf {
+        self.sandbox
+            .store
+            .join(CAPTURES_NAME)
+            .join(&class[..SLOT_NAME_LEN])
+    }
+}
+
+/// Stages the placeholder of a test's templates in the directory `platform`, and returns it: a
+/// copy of the fixtures' Ubuntu EROFS image, beside a copy of its manifest, which a creation
+/// verifies.
+///
+/// A platform stages its trusted artifacts where no one else may change them, and NVX's capture
+/// refuses a placeholder that anyone else may change. So the directory is private to the current
+/// user, as NVX makes a sandbox's store, whose access control list on Windows passes on to the
+/// files created in it, and each copy has the mode 0644 on Unix, whatever the umask.
+fn stage(platform: &Path, fixtures: &Fixtures) -> PathBuf {
+    SandboxStore::create(platform).unwrap();
+    let [placeholder, _] = [&fixtures.distro, &fixtures.manifest].map(|source| {
+        let copy = platform.join(source.file_name().unwrap());
+        io::copy(
+            &mut File::open(source).unwrap(),
+            &mut File::create(&copy).unwrap(),
+        )
+        .unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt as _;
+            fs::set_permissions(&copy, fs::Permissions::from_mode(0o644)).unwrap();
+        }
+        copy
+    });
+    placeholder
+}
+
+/// Returns `parameter` as the command line spells it: its name, then `=` and its value, if it has
+/// one.
+fn token(parameter: &Parameter<'_>) -> Vec<u8> {
+    let mut token = parameter.name.to_vec();
+    if let Some(value) = parameter.value {
+        token.push(b'=');
+        token.extend_from_slice(value);
+    }
+    token
+}
+
+/// Returns the names of the entries of the directory `path`, sorted.
+fn names(path: &Path) -> Vec<String> {
+    let mut names: Vec<String> = fs::read_dir(path)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name().into_string().unwrap())
+        .collect();
+    names.sort();
+    names
+}
+
+/// Checks that the store of `templates` captured `template`, as the creation that printed
+/// `created` says, and published it as its one generation, as the
+/// [module documentation](self) describes.
+fn assert_captured(templates: &Templates, created: &Printed, template: &Template) {
+    assert_eq!(created["created"], "captured", "{created:?}");
+    assert_eq!(created["generation"], "1", "{created:?}");
+    let store = templates.store();
+    let index = store.index().unwrap();
+    let [generation] = index.generations() else {
+        panic!("the store indexes {:?}", index.generations());
+    };
+    assert_eq!(generation.generation().to_string(), "1");
+    assert_eq!(generation.key().to_string(), created["key"]);
+    assert_eq!(generation.class().to_string(), created["class"]);
+    let key = store.read_key(generation).unwrap();
+    assert_eq!(key.identity(), generation.key());
+
+    // The runtime of the adapter's VMs, with the guest agent's build, and the machine that the
+    // scenario asked for.
+    let artifacts = env::var_os(Artifacts::ENV_DIR).unwrap();
+    let runtime = Runtime::from_dir(artifacts, GUEST_BUILD).unwrap();
+    assert_eq!(key.runtime(), &runtime.identity);
+    assert_eq!(
+        key.guest_build().as_str(),
+        format!("runtime-adapter-guest/{GUEST_BUILD}")
+    );
+    assert_eq!(key.hypervisor(), Hypervisor::from_env_or_default().unwrap());
+    let processors = template.processors();
+    assert_eq!(key.processors(), processors);
+    // Every processor is online at boot, so a restore activates none.
+    assert_eq!(key.boot_processors(), 0);
+    assert_eq!(key.memory(), template.memory());
+    assert_eq!(key.memory_capacity(), template.memory_capacity());
+    let placeholder = fs::metadata(&templates.placeholder).unwrap().len();
+    let distro = key.distro();
+    assert_eq!(
+        (distro.length, distro.logical_block_size),
+        (placeholder, LOGICAL_BLOCK_SIZE)
+    );
+    let scratch = key.scratch();
+    assert_eq!(
+        (scratch.length, scratch.logical_block_size),
+        (template.scratch_length(), LOGICAL_BLOCK_SIZE)
+    );
+    assert_eq!(key.has_network(), template.network.has_nic());
+
+    // The kernel command line, which every clone restores: the platform tier's tokens alone,
+    // which OpenVMM's capture admits, with the processors, and the NIC's addresses exactly when
+    // the template has a NIC, but neither the placeholder's identity nor a root's tokens.
+    let command_line = key.command_line();
+    let tokens: Vec<Vec<u8>> = cmdline::parameters(command_line.as_bytes())
+        .map(|parameter| token(&parameter))
+        .collect();
+    for token in &tokens {
+        assert!(
+            is_platform_token(token),
+            "{} in {command_line}",
+            token.escape_ascii()
+        );
+    }
+    for expected in [
+        "nvx_sandbox=1".to_owned(),
+        "nvx_snapshot_tier=platform".to_owned(),
+        format!("nr_cpus={processors}"),
+    ] {
+        assert!(
+            tokens.iter().any(|token| token == expected.as_bytes()),
+            "{expected} in {command_line}"
+        );
+    }
+    assert_eq!(
+        tokens.iter().any(|token| token.starts_with(b"virtnet_ip=")),
+        template.network.has_nic(),
+        "{command_line}"
+    );
+    for tenant in [templates.identity.as_str(), "nvx_layer", "nvx_scratch"] {
+        assert!(!command_line.contains(tenant), "{tenant} in {command_line}");
+    }
+
+    // The payload: the record of the capture, the key, and the snapshot, as OpenVMM published it.
+    let payload = templates
+        .sandbox
+        .store
+        .join(GENERATIONS_NAME)
+        .join(generation.generation().to_string());
+    assert_eq!(
+        names(&payload),
+        [CAPTURE_RECORD_NAME, KEY_NAME, SNAPSHOT_NAME]
+    );
+    let snapshot = store.snapshot_dir(generation).unwrap();
+    assert_eq!(snapshot, payload.join(SNAPSHOT_NAME));
+    assert!(snapshot.join(MANIFEST_NAME).is_file());
+
+    // The class's slot holds no transaction once the capture published it, and records no launch
+    // once its VM ended.
+    let slot = templates.slot(&created["class"]);
+    assert!(!slot.join(TRANSACTION_NAME).exists());
+    let slot = SandboxStore::open(&slot).unwrap();
+    assert!(slot.journal().unwrap().is_none());
+    assert!(slot.runtime().unwrap().is_none());
+}
+
+/// Creates `template` in a template store of its own, in the sandbox of the test `name`, checks
+/// that the store captured it and published it, and that a second creation of its class serves
+/// that generation, without a capture.
+fn captures(name: &str, template: Template) {
+    let mut templates = Templates::new(name);
+    let created = templates.create(&template, 0);
+    assert_captured(&templates, &created, &template);
+    let log = templates.slot(&created["class"]).join(LOG_NAME);
+    let captured = fs::read(&log).unwrap();
+
+    let existing = templates.create(&template, 0);
+    assert_eq!(existing["created"], "existing", "{existing:?}");
+    for printed in ["generation", "key", "class"] {
+        assert_eq!(existing[printed], created[printed], "{printed}");
+    }
+    assert_eq!(templates.store().index().unwrap().generations().len(), 1);
+    // No VMM ran since the capture's, whose log the slot keeps.
+    assert_eq!(fs::read(&log).unwrap(), captured);
+}
+
+/// Creates `template` in a template store of its own, in the sandbox of the test `name`, and
+/// checks that NVX refuses its network with `problem` before any VM starts: the store indexes no
+/// generation, and no VMM ran in any slot.
+fn refuses(name: &str, template: Template, problem: &str) {
+    let mut templates = Templates::new(name);
+    templates.create(&template, FAILED);
+    let stderr = templates.sandbox.stderr();
+    assert!(stderr.contains(problem), "{stderr}");
+    assert!(templates.store().index().unwrap().generations().is_empty());
+    let slots = fs::read_dir(templates.sandbox.store.join(CAPTURES_NAME))
+        .into_iter()
+        .flatten();
+    for slot in slots {
+        let slot = slot.unwrap().path();
+        for name in [LOG_NAME, TRANSACTION_NAME] {
+            assert!(!slot.join(name).exists(), "{}", slot.display());
+        }
+    }
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn a_template_without_a_network_has_no_nic() {
+    // Every processor is online at boot, and a restore may expand the RAM to its capacity.
+    let template = Template {
+        processors: Some(2),
+        memory: Some(2 * MEMORY_BLOCK_SIZE),
+        memory_capacity: Some(4 * MEMORY_BLOCK_SIZE),
+        scratch_length: Some(32 * MIB),
+        ..Template::new(Network::None)
+    };
+    captures("tpl-none", template);
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn a_network_that_lets_nothing_through_has_no_nic() {
+    captures("tpl-deny", Template::new(Network::Deny));
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn an_egress_network_has_its_nic() {
+    captures("tpl-egress", Template::new(Network::Egress));
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn an_allow_rule_has_its_nic() {
+    captures("tpl-rule", Template::new(Network::AllowRule));
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn outbound_host_loopback_has_its_nic() {
+    captures("tpl-outbound", Template::new(Network::Outbound));
+}
+
+#[test]
+#[ignore = "boots a VM; see the module documentation for what it needs"]
+fn a_proxy_only_network_has_its_nic() {
+    captures("tpl-proxy", Template::new(Network::Proxy));
+}
+
+#[test]
+#[ignore = "needs NVX's artifacts; see the module documentation"]
+fn ingress_is_refused_before_any_vm_starts() {
+    refuses(
+        "tpl-ingress",
+        Template::new(Network::Ingress),
+        "a template's network policy cannot allow ingress",
+    );
+}
+
+#[test]
+#[ignore = "needs NVX's artifacts; see the module documentation"]
+fn host_loopback_both_ways_is_refused_before_any_vm_starts() {
+    refuses(
+        "tpl-loopback",
+        Template::new(Network::HostLoopback),
+        "a template's network policy cannot allow host-loopback access both ways",
+    );
+}
+
+#[test]
+#[ignore = "needs NVX's artifacts; see the module documentation"]
+fn a_class_that_no_capture_takes_is_refused_before_the_store() {
+    let mut templates = Templates::new("tpl-class");
+    let template = Template {
+        processors: Some(3),
+        ..Template::new(Network::None)
+    };
+    templates.create(&template, FAILED);
+    let stderr = templates.sandbox.stderr();
+    assert!(stderr.contains("needs 1, 2, 4, or 8 of each"), "{stderr}");
+    assert!(!templates.sandbox.store.exists());
+}