diff --git a/README.md b/README.md
index 3cc750c..2969938 100644
--- a/README.md
+++ b/README.md
@@ -81,7 +81,7 @@ lyracore packages disable NAME [--yes]
 lyracore packages remove NAME [--yes]
 lyracore packages build
 lyracore packages check
-lyracore packages replay [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
+lyracore packages apply [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
 lyracore packages config NAME [KEY [VALUE]] [--new]
 ```
 
@@ -154,7 +154,7 @@ no `--accept` option.
 | `packages remove NAME` | Delete a disabled Package after confirmation. Refuse changes to its recorded Content Identity. |
 | `packages build` | Refresh typings, install pinned Bun dependencies, typecheck and run Datascripts, compile Runtime Scripts, and check the generated artifacts together. |
 | `packages check` | Check Package Deltas and Script Artifacts against their inputs, refreshing typings when needed. Preflight also runs this check. |
-| `packages replay` | Apply enabled Packages' spell Package Deltas and reconcile Runtime Scripts on each target Shard. |
+| `packages apply` | Prepare installed sources, publish Rust Packages, and apply artifacts on each target Shard. |
 | `packages config NAME [KEY [VALUE]]` | List Package Config, read one key, or write one key on every recorded fixture Shard. |
 
 A bare name such as `playerbots` selects a Package from the
@@ -164,7 +164,7 @@ must contain one Package at its root. Use `./my-package` to select a local folde
 ```bash
 lyracore packages add playerbots
 lyracore packages list
-lyracore packages replay --check
+lyracore packages apply --check
 ```
 
 Adding, updating, enabling, or disabling a Package does not publish the Module or sync a client.
@@ -172,8 +172,10 @@ Follow the next steps the command prints. Package Teardown deletes the Package's
 before disabling it on a recorded dev node, so the command asks first. Without a recorded node it
 moves the folder and reports any tables that still need teardown before publishing.
 
-`packages replay` uses the recorded fixture Shards unless you name destinations. `--check` prints
-the plan without changing Shards. Replays skip Import Families whose recorded inputs already
+`packages apply` uses the recorded fixture Shards unless you name destinations. `--check` prints
+the plan without changing Shards. It can build local artifacts. `apply` prepares missing or stale
+artifacts and publishes the Module when the Package Inventory contains Rust or a target records
+pending Package Teardown. Artifact application skips Import Families whose recorded inputs already
 match, so a retry resumes unfinished work; `--force-all` reapplies matching families too.
 `--client-data PATH` supplies the client archives needed for the spell family. An empty enabled
 Package set also reconciles state, removing Runtime Scripts and spell changes from disabled
@@ -183,8 +185,8 @@ Packages.
 a key. Reads report disagreements between Shards. Use `lyracore config` for the client path;
 Package Config holds the values a Package reads at runtime.
 
-Use `--yes` to answer the confirmation for `add`, `update`, `disable`, `remove`, or `replay` in
-advance. It does not bypass their checks. Bun is needed for authoring with `packages build`;
+Use `--yes` to answer the confirmation for `add`, `update`, `disable`, `remove`, or `apply` in
+advance. It does not bypass their checks. Bun is needed when `build` or `apply` must compile sources;
 applying a prebuilt Package does not require it.
 
 `packages build` records a Build Identity for each artifact it generates. Datascripts need a Base
diff --git a/docs/commands.md b/docs/commands.md
index f3c7d95..d54b171 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -71,7 +71,7 @@ lyracore packages enable NAME
 lyracore packages list
 lyracore packages new NAME [--from RUNG]
 lyracore packages remove NAME [--yes]
-lyracore packages replay [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
+lyracore packages apply [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
 lyracore packages update [NAME] [--yes]
 lyracore character gm NAME true|false
 lyracore production status --server SERVER --gateway-log PATH --realm-core DB DATABASE ...
@@ -104,7 +104,7 @@ lyracore update
 | `packages list` | every installed Package: enabled or disabled, where it came from, and whether it has drifted |
 | `packages new` | copy and rename a Reference Package from the collection tag matching this checkout's Package API |
 | `packages remove` | delete a disabled Package, after a confirmation and a check for local changes |
-| `packages replay` | reapply every enabled Package's claims and Runtime Scripts onto the named Shards, or the whole recorded fixture topology by default |
+| `packages apply` | prepare installed sources, publish Rust Packages, and apply artifacts to the named Shards or recorded development topology |
 | `packages update` | update Git Package Sources from their repository and Official Package Sources from the compatible collection tag |
 | `character gm` | flip GM commands on or off for a character, on whichever world shard has it |
 | `production status` | read-only checks for an explicitly named production topology and the latest gateway start |
@@ -284,11 +284,11 @@ installed in its place. The Provenance Stamp records the collection's URL and th
 directory was resolved at. `packages update` can advance the installed Package to the current
 commit at the compatible tag, after the normal Trust Review and confirmation.
 
-**It publishes nothing.** The two remaining steps are printed for you to run:
+The command prints the next steps for the content it installed:
 
 ```bash
-./lyracore publish        # compile the Package in and publish it to every database
-./lyracore client sync    # if the Package ships addons or client overrides
+./lyracore packages apply # prepare and activate installed Packages
+./lyracore client sync    # if the Package ships client content
 ```
 
 A failed `preflight` leaves the copy in place, says the module on the node is unchanged, and names
@@ -315,9 +315,9 @@ Each `<name>.<script file stem>` must also fit the 64-character Runtime Script n
 
 Generated artifacts are omitted because the renamed sources need new Build Identities. Before
 using a copy beside another, choose distinct `@id` values for Runtime Scripts or a distinct Package
-Spell ID in its Datascript. Run `packages build` after editing the sources. A Datascript also needs
-a Base Snapshot from your own client data. Replay the built artifacts through the normal realm
-update; use `client sync` for a client half. Scaffolding requires network access to the collection.
+Spell ID in its Datascript. Run `packages apply` to build and activate the copy. A Datascript
+needs your own client data. Use `client sync` for a client half. Scaffolding requires network
+access to the collection.
 
 ## `packages enable`, `disable`, `remove` — taking a Package out of the build
 
@@ -366,12 +366,11 @@ The off path for a Package on a running Realm:
 
 ```bash
 ./lyracore packages disable playerbots   # asks, tears down every Shard, then moves the folder
-./lyracore publish                       # the Module without the Package; its empty tables go
-./lyracore packages replay               # removes the Package's Runtime Scripts from every Shard
+./lyracore packages apply                # publish without its Rust and remove its artifacts
 ./lyracore client sync                   # only when the Package ships client content
 ```
 
-`packages enable` followed by `publish` brings the Package back fresh: empty tables and default
+`packages enable` followed by `packages apply` brings the Package back fresh: empty tables and default
 Package Config. Its Dormant Characters stay as they are, and the Package creates new ones.
 
 **`packages remove NAME` deletes, so it has gates.** It requires the Package to be disabled already,
@@ -414,7 +413,7 @@ disabled and is excluded from compilation. The old folder is deleted only after
 the candidate is discarded, and the error names both commits. `update` publishes nothing and
 synchronizes no client; it prints the steps it did not run.
 
-Applying and replaying Package Deltas is `packages replay`, below.
+Apply Package Deltas with `packages apply`, below.
 
 ## `packages config` — a Package's key-values, on every Shard
 
@@ -430,7 +429,7 @@ its own defaults when it initialises, so the list shows real keys with live valu
 
 **The rows are per-Shard state.** Every database of the fixture topology holds its own copy, and the
 Module coordinates none of them. A write therefore goes to every Shard of the recorded topology, the
-same set `packages replay` uses when no database is named. A read visits every Shard too: when they
+same set `packages apply` uses when no database is named. A read visits every Shard too: when they
 do not agree on a key, the command names each Shard's answer instead of printing one of them. A
 Shard with no row for the key reads as `(unset)`, which is the same kind of disagreement.
 
@@ -485,7 +484,7 @@ with neither builds exactly as it did before those steps existed:
    `@event` fails with the file that holds it. Fail-fast, the same way step 5 is.
 7. `lyracore-delta-check` traces every enabled Package's generated artifacts together, in one
    invocation, Package Deltas and Script Artifacts alike. This is the same authoritative Rust-side
-   check `packages replay` runs before it writes to a Shard, so a Claim Conflict or a Runtime Script
+   check `packages apply` runs before it writes to a Shard, so a Claim Conflict or a Runtime Script
    collision between two Packages is caught by the one implementation that also decides whether it
    may apply, not by a second, looser one.
 8. A **Build Identity** sidecar is written next to each source-built artifact that just validated:
@@ -538,8 +537,8 @@ The Build Identity covers both source directories, so editing either requires a
 
 ### Bun is author-side only
 
-`packages build` is the only command that needs Bun, and authoring Datascripts is the only reason
-to run it. **An Operator applying a prebuilt Package needs no Bun and no Node.** Nothing in
+`packages build` needs Bun. `packages apply` runs that build when installed sources need new
+artifacts. **An Operator applying a prebuilt Package needs no Bun and no Node.** Nothing in
 `dev up`, `preflight`, `publish` or `client sync` invokes a JavaScript toolchain. That is why
 `doctor` reports a missing or different Bun version as a warning and never as a launch blocker.
 
@@ -548,7 +547,7 @@ Install the pinned version with
 
 Datascripts are **trusted author-time code**, run from this checkout by the person who wrote them.
 They are not sandboxed and are not described as sandboxed. `packages build` above is what turns one
-into a Package Delta; `packages replay`, below, is what applies it to a Shard.
+into a Package Delta; `packages apply`, below, is what applies it to a Shard.
 
 ### Runtime Scripts — `packages/<name>/scripts/`
 
@@ -633,60 +632,57 @@ prebuilt Lua and needs no Bun. In this checkout they are git-ignored output: the
 them are the repository content, and a committed copy would go stale the moment the Module schema or
 the pinned toolchain moved.
 
-## `packages replay` — reapply a Package's artifacts across the Realm
+## `packages apply`
 
-A Package's artifacts are not a one-shot edit. Its catalogues live on every World Shard and
-Instance Pool that owns a copy, so every edit has to reach all of them.
+Prepare and activate the installed Packages on a running Realm:
 
-    lyracore packages replay [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
-
-With no names it targets every Shard of the recorded fixture topology. Named Shards are used
-exactly as given. It takes Shard names only; anything flag-shaped is refused before a process
-starts, and it never infers a production Shard list.
-
-### The two Import Families it carries
-
-**spell.** The artifact is a Package Delta: claims on columns of rows a base import owns. A base
-import replaces the whole family, so the claims replay as the last stage of that family's import.
-The Shard therefore reimports `Spell.dbc` first, through the importer, and the claims go on top.
-
-**script.** The artifact is a Script Artifact: whole `game_script` rows. No DBC and no dump holds a
-Runtime Script, so this family has no base import and nothing to reload first. The whole enabled
-plan goes straight to `apply_package_deltas` in one transaction, and applying it IS the
-reconciliation: the Shard ends up holding exactly the scripts the enabled Packages ship and nothing
-else.
-
-### The run
-
-1. Preflight. Every enabled Package's artifact is read and digested once, and every target's
-   provenance is read, per family. An unreadable artifact, a Package named twice, a Claim Conflict,
-   a Runtime Script collision, or an unreachable Shard fails the run before the first write.
-2. Apply, Shard by Shard in order. Each Shard takes the spell family through the importer, then the
-   script family through the reducer.
-3. Stop at the first failure and name the Shard and family. The report lists completion per family,
-   including a spell apply that finished on the Shard before its script apply refused the plan. It
-   also lists untouched Shards and prints the command to resume.
-
-Resume is the default, and it is decided per family. A Shard is reported complete for a family and
-skipped when every enabled Package is recorded in `game_package_import` with the digest this
-checkout produces, and no Package is recorded that is no longer enabled. The spell family
-additionally requires every row to sit on the Shard's current base import stamp; the script family
-has no base import to sit on. Re-running after a failure therefore costs nothing on completed
-families, and a Shard already holding this checkout's Package Deltas is still replayed for its
-Runtime Scripts. `--force-all` replays anyway.
-
-`--check` prints both plans, writes nothing, and asks nothing. It runs the spell importer when the
-checkout has a Package Delta plan, or when a Shard needs an empty spell reconciliation. When only
-script-family work remains, a check needs no client Data directory.
-
-Disabling a Package is a replay, not a deletion. Its folder leaves `packages/`, so its artifacts
-leave both payloads: the reducer clears the Package Spell Range as it applies the spell family, and
-the empty script plan is still sent, which is what takes the Package's Runtime Scripts off every
-Shard. Both are destructive and the confirmation names them.
+```bash
+lyracore packages apply [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]
+```
 
-The other claim families a Package may claim in (items, quests, loot, casts and trainers) are NOT
-replayed here. Their base import is the world dump rather than a DBC, which is a much larger and
-more destructive reload than this verb owns. Reapply those with the importer's own dump modes.
+With no Shard names, the command uses the recorded development topology. Named Shards are used
+exactly as given. It never infers a production Shard list. Run it from the checkout whose Module
+and Packages you intend to deploy, with an Operator identity on each target.
+
+The command checks Build Identities and builds missing or stale artifacts from installed sources.
+A Datascript needs the pinned Bun version and your own client data. If its Base Snapshot is missing,
+`apply` extracts one locally. Use `--client-data PATH` or `lyracore config set client-data PATH` to
+select the client's Data directory. A current Script Artifact needs neither Bun nor client data.
+Source-free Package Deltas must already have a current Build Identity; install updated source or
+artifacts if they are stale. Generated Package Deltas remain local.
+
+Before writing, the command validates artifacts, checks conflicts, reads every target's provenance,
+and asks once for the planned Realm changes. `--yes` answers that confirmation in advance.
+`--check` prepares local artifacts and validates the plan without publishing or calling a reducer.
+Local generated files can change during a check.
+
+If the Package Inventory contains Rust, or a target records pending Package Teardown, `apply`
+publishes this checkout's Module. It keeps the normal preflight and Loot Roll upgrade checks and
+repairs schedules on each published Shard before continuing. Rust Packages cause a publish on
+every run; artifact provenance does not track compiled Rust. Disable a Rust Package through
+`packages disable` before removing it so its tables and Characters receive Package Teardown.
+
+Each Shard completes its publish and schedule repair, when needed, before applying artifacts.
+Only then does the command continue to the next Shard:
+
+- The spell Import Family reimports `Spell.dbc`, then applies the enabled Package Deltas.
+- The script Import Family reconciles `game_script` to the enabled Script Artifacts in one
+  transaction. A script-only run needs no base import or Module publish.
+
+A family whose Package Import records already match the enabled artifacts is skipped. For spells,
+the records must also match the Shard's current base import. `--force-all` applies both families even
+when they match. An empty enabled set removes previously applied Package spells and Runtime Scripts;
+the confirmation names these removals.
+
+A failure stops the run and reports completed and remaining work. Retry the printed command after
+fixing the cause. Completed artifact families are skipped. A Module publish can disconnect clients;
+a failed schedule repair names the published Shard and the repair command.
+
+Other claim families use the importer's world-dump modes. This command owns spell and script
+artifacts only. Client content is installed separately with `lyracore client sync`.
+
+The old name, `packages replay`, is refused with a migration hint. It is not an alias because
+`apply` can build sources and publish Rust Packages.
 
 ## `packages check` — is every generated artifact still current?
 
diff --git a/src/bin/main.rs b/src/bin/main.rs
index bea39f9..d3490c7 100644
--- a/src/bin/main.rs
+++ b/src/bin/main.rs
@@ -153,10 +153,10 @@ fn run(args: &[String]) -> Result<i32> {
             yes,
         )
         .map(|_| EXIT_OK),
-        Command::PackagesReplay(options) => cmd::packages::replay::run(
+        Command::PackagesApply(options) => cmd::packages::apply::run(
             &ProjectLayout::discover()?,
             &runner,
-            &cmd::import::TtyPrompt::packages_replay(),
+            &cmd::import::TtyPrompt::packages_apply(),
             &options,
         )
         .map(|_| EXIT_OK),
diff --git a/src/cmd/import.rs b/src/cmd/import.rs
index 954af4e..d13494c 100644
--- a/src/cmd/import.rs
+++ b/src/cmd/import.rs
@@ -115,9 +115,9 @@ impl TtyPrompt {
         }
     }
 
-    pub const fn packages_replay() -> Self {
+    pub const fn packages_apply() -> Self {
         Self {
-            no_terminal_remedy: "pass --yes to confirm the replay in advance, or --check to see \
+            no_terminal_remedy: "pass --yes to confirm the application in advance, or --check to see \
                                  the plan without writing",
         }
     }
diff --git a/src/cmd/mod.rs b/src/cmd/mod.rs
index bb3f58c..97bf300 100644
--- a/src/cmd/mod.rs
+++ b/src/cmd/mod.rs
@@ -132,21 +132,13 @@ USAGE:
                                                first, and refuses a folder that no longer matches
                                                its recorded content identity, because those local
                                                changes exist nowhere else
-  lyracore packages replay [DATABASE ...] [--check] [--yes] [--force-all]
-                                               reapply every enabled Package's artifacts to each
-                                               named Shard, in two Import Families. spell: reimport
-                                               Spell.dbc, then replay the Package Deltas over it.
-                                               script: reconcile the Runtime Scripts to exactly the
-                                               ones the enabled Packages ship, which is also how a
-                                               disabled Package's scripts leave a Shard. Preflights
-                                               every artifact and every target before the first
-                                               write, applies Shard by Shard, and stops at the first
-                                               failure naming the Shard, the family, what completed
-                                               and what was never touched. A Shard whose recorded
-                                               provenance for a family already matches this checkout
-                                               is skipped for it, so re-running resumes. --check
-                                               prints the plan and writes nothing; --force-all
-                                               replays even the Shards that match
+  lyracore packages apply [DATABASE ...] [--check] [--yes] [--force-all]
+                                               prepare installed sources, publish the Module for
+                                               Rust Packages, then apply artifacts to each Shard.
+                                               Defaults to the recorded development topology.
+                                               --check prepares and validates without Realm writes;
+                                               --force-all also applies matching artifacts.
+                                               --client-data PATH supplies the client Data directory
   lyracore packages config NAME [KEY [VALUE]] [--new]
                                                read and write an installed Package's Package Config
                                                — the durable key-values it reads at runtime. With no
@@ -280,7 +272,7 @@ pub enum Command {
         /// `--yes`: the deletion confirmation was answered in advance (scripted runs).
         yes: bool,
     },
-    PackagesReplay(packages::replay::ReplayOptions),
+    PackagesApply(packages::apply::ApplyOptions),
     PackagesConfig(packages::config::ConfigOptions),
     ProductionStatus(production::StatusOptions),
     /// The one root-only, system-state verb on this surface, deliberately its own: `update` stays
@@ -421,7 +413,10 @@ impl Command {
                 "`packages list` takes no arguments (got '{other}')"
             ))),
             ["packages", "new", rest @ ..] => parse_packages_new(rest),
-            ["packages", "replay", rest @ ..] => parse_packages_replay(rest),
+            ["packages", "apply", rest @ ..] => parse_packages_apply(rest),
+            ["packages", "replay", ..] => Err(Error::Usage(
+                "`packages replay` was renamed to `packages apply`. The new command also builds stale artifacts and publishes Rust Packages. Use `packages apply --check` to inspect its plan.".to_string()
+            )),
             ["packages", "config", rest @ ..] => parse_packages_config(rest),
             ["packages", "build"] => Ok(Command::PackagesBuild),
             ["packages", "build", other, ..] => Err(Error::Usage(format!(
@@ -445,7 +440,7 @@ impl Command {
             ["packages", ..] => Err(Error::Usage(
                 "`packages` supports: add FOLDER|GIT-URL [--yes], build, check, config NAME [KEY \
                  [VALUE]] [--new], disable NAME [--yes], enable NAME, list, new NAME, remove NAME \
-                 [--yes], replay [DATABASE ...] [--check] [--yes] [--force-all], update [NAME] \
+                 [--yes], apply [DATABASE ...] [--check] [--yes] [--force-all], update [NAME] \
                  [--yes]"
                     .to_string(),
             )),
@@ -646,15 +641,15 @@ fn parse_packages_update(args: &[&str]) -> Result<Command> {
     Ok(Command::PackagesUpdate { name, yes })
 }
 
-/// `packages replay [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]`.
+/// `packages apply [DATABASE ...] [--check] [--yes] [--force-all] [--client-data PATH]`.
 ///
 /// Flags and Shard names interleave freely, but a Shard name is validated the moment it is taken:
 /// anything flag-shaped that is not one of this verb's own options is REFUSED rather than passed on
 /// to a subprocess, exactly as `publish` refuses it. An empty list is not a default target list — it
-/// means "none named", which `replay` resolves against the recorded development topology once it can
+/// means "none named", which `apply` resolves against the recorded development topology once it can
 /// read one.
-fn parse_packages_replay(args: &[&str]) -> Result<Command> {
-    let mut options = packages::replay::ReplayOptions::default();
+fn parse_packages_apply(args: &[&str]) -> Result<Command> {
+    let mut options = packages::apply::ApplyOptions::default();
     let mut rest = args.iter();
     while let Some(arg) = rest.next() {
         match *arg {
@@ -673,17 +668,17 @@ fn parse_packages_replay(args: &[&str]) -> Result<Command> {
             }
             option if option.starts_with("--") => {
                 return Err(Error::Usage(format!(
-                    "unknown `packages replay` option '{option}' — the options are --check, --yes, \
+                    "unknown `packages apply` option '{option}' — the options are --check, --yes, \
                      --force-all and --client-data PATH"
                 )))
             }
             name => {
-                publish::validate_database(packages::replay::VERB, name)?;
+                publish::validate_database(packages::apply::VERB, name)?;
                 options.databases.push(name.to_string());
             }
         }
     }
-    Ok(Command::PackagesReplay(options))
+    Ok(Command::PackagesApply(options))
 }
 
 fn parse_packages_new(args: &[&str]) -> Result<Command> {
@@ -723,7 +718,7 @@ fn parse_packages_new(args: &[&str]) -> Result<Command> {
 
 /// `client pack --out DIR [--zip]`.
 ///
-/// `--out` and `--zip` interleave freely, the same as `packages replay`'s options — but this verb
+/// `--out` and `--zip` interleave freely, the same as `packages apply`'s options — but this verb
 /// has no bare positional of its own, so anything that is not one of the two options is refused as
 /// an extra argument rather than folded into a Shard-name-shaped list.
 fn parse_client_pack(args: &[&str]) -> Result<Command> {
@@ -1773,14 +1768,14 @@ mod tests {
     }
 
     #[test]
-    fn packages_replay_takes_shard_names_and_its_own_options_in_any_order() {
+    fn packages_apply_takes_shard_names_and_its_own_options_in_any_order() {
         assert_eq!(
-            parse("packages replay").unwrap(),
-            Command::PackagesReplay(packages::replay::ReplayOptions::default())
+            parse("packages apply").unwrap(),
+            Command::PackagesApply(packages::apply::ApplyOptions::default())
         );
         assert_eq!(
-            parse("packages replay lyracore --check lyracore-kalimdor --force-all --yes").unwrap(),
-            Command::PackagesReplay(packages::replay::ReplayOptions {
+            parse("packages apply lyracore --check lyracore-kalimdor --force-all --yes").unwrap(),
+            Command::PackagesApply(packages::apply::ApplyOptions {
                 databases: vec!["lyracore".to_string(), "lyracore-kalimdor".to_string()],
                 client_data: None,
                 check: true,
@@ -1789,8 +1784,8 @@ mod tests {
             })
         );
         assert_eq!(
-            parse("packages replay --client-data /games/Data lyracore").unwrap(),
-            Command::PackagesReplay(packages::replay::ReplayOptions {
+            parse("packages apply --client-data /games/Data lyracore").unwrap(),
+            Command::PackagesApply(packages::apply::ApplyOptions {
                 databases: vec!["lyracore".to_string()],
                 client_data: Some("/games/Data".to_string()),
                 ..Default::default()
@@ -1801,12 +1796,12 @@ mod tests {
     /// The same guard `publish` has: a Shard list is names only, and a flag hidden among them is
     /// refused at parse time rather than forwarded to the importer.
     #[test]
-    fn packages_replay_refuses_a_flag_shaped_shard_name() {
+    fn packages_apply_refuses_a_flag_shaped_shard_name() {
         for line in [
-            "packages replay -c",
-            "packages replay lyracore --delete-data",
-            "packages replay --unknown",
-            "packages replay --client-data",
+            "packages apply -c",
+            "packages apply lyracore --delete-data",
+            "packages apply --unknown",
+            "packages apply --client-data",
         ] {
             assert!(parse(line).is_err(), "{line}");
         }
diff --git a/src/cmd/packages/replay.rs b/src/cmd/packages/apply.rs
similarity index 70%
rename from src/cmd/packages/replay.rs
rename to src/cmd/packages/apply.rs
index b63e1ba..54b04f8 100644
--- a/src/cmd/packages/replay.rs
+++ b/src/cmd/packages/apply.rs
@@ -1,26 +1,17 @@
-//! `lyracore packages replay [DATABASE …] [--check] [--yes] [--force-all]` — reapply every enabled
-//! Package's artifacts to every Shard that holds a copy of the catalogues they claim.
-//!
-//! Two Import Families travel here. **spell** claims columns of rows a base import owns, so it
-//! replays as the last stage of that import. **script** owns whole `game_script` rows with no base
-//! import behind it, so its apply goes straight to `apply_package_deltas` and IS the reconciliation
-//! — an empty plan is still applied, because that is how a disabled Package's scripts leave a Shard.
-//!
-//! Over calling the module per Shard, this verb adds: preflight (every artifact read, digested, and
-//! traced once, before any write), resume (a Shard whose per-family provenance already matches this
-//! checkout is skipped for that family), and an honest report naming what completed, what failed,
-//! and what was never touched.
-//!
-//! Fail-fast, never rollback: a half-applied Realm is recoverable by re-running, but one that
-//! reported success while half-applied is not.
+//! Prepare and activate installed Packages on explicitly named Shards or the development topology.
+//! Sources build when artifacts are missing or stale. Rust Packages and pending Package Teardown
+//! require a Module publish and schedule repair. Artifact provenance skips completed families.
+//! Confirmation precedes all Realm writes. Failures stop the run and identify the remaining work.
 
 use std::path::Path;
 
 use crate::cmd::import::{self, Prompt};
 use crate::cmd::packages::artifact::{self, Artifact, SPELL_FAMILY};
 use crate::cmd::packages::script::{self, ScriptArtifact, SCRIPT_FAMILY};
+use crate::cmd::packages::{check, inventory};
 use crate::cmd::packages::{recorded_databases, shard_list};
 use crate::cmd::publish::validate_database;
+use crate::cmd::{preflight, publish};
 use crate::proc::{CommandSpec, ProcessRunner};
 use crate::project::ProjectLayout;
 use crate::{Error, Result};
@@ -28,19 +19,18 @@ use crate::{Error, Result};
 /// The reducer that applies one family's whole enabled plan in one transaction.
 const APPLY_REDUCER: &str = "apply_package_deltas";
 
-/// What `packages replay` was asked to do.
+/// What `packages apply` was asked to do.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct ReplayOptions {
-    /// The Shards to replay onto. Empty means the recorded development topology — never a guessed
+pub struct ApplyOptions {
+    /// The Shards to apply onto. Empty means the recorded development topology — never a guessed
     /// production list.
     pub databases: Vec<String>,
     pub client_data: Option<String>,
-    /// Run the whole plan and write nothing: preflight, then the importer's own check mode per
-    /// Shard. No confirmation, because nothing changes.
+    /// Prepare locally and check the plan without Realm writes.
     pub check: bool,
     /// Answer the confirmation in advance.
     pub yes: bool,
-    /// Replay every named Shard, including ones whose provenance already matches.
+    /// Apply every named Shard, including ones whose provenance already matches.
     pub force_all: bool,
 }
 
@@ -70,7 +60,7 @@ impl Target {
 }
 
 /// The verb name this module's refusals quote back at the operator.
-pub const VERB: &str = "packages replay";
+pub const VERB: &str = "packages apply";
 
 /// Validate the Shard names given on the command line.
 ///
@@ -86,7 +76,7 @@ pub fn databases(args: &[String]) -> Result<Vec<String>> {
 /// The single-Shard contract this verb orchestrates: reimport the spell family from the client's
 /// `Spell.dbc`, then reapply the enabled Packages' Deltas over it. Without `--apply` the importer
 /// prints the plan and writes nothing.
-fn replay_command(
+fn apply_command(
     project: &ProjectLayout,
     database: &str,
     client_data: &Path,
@@ -124,7 +114,7 @@ fn rows(output: &str, columns: &[&str]) -> Vec<Vec<String>> {
 /// One read of one Shard, with the diagnosis a failure needs.
 ///
 /// A failed query is not an empty result — conflating them would read a dead node as "never
-/// applied" and replay a Realm this verb cannot actually see.
+/// applied" and apply a Realm this verb cannot actually see.
 fn ask(
     project: &ProjectLayout,
     runner: &dyn ProcessRunner,
@@ -136,7 +126,7 @@ fn ask(
         .map_err(|e| {
             Error::Process(format!(
                 "could not read Package artifact provenance from '{database}': {e}\n  A failed \
-                 query is not an empty result, so nothing was replayed. Check that the node is up \
+                 query is not an empty result, so nothing was applied. Check that the node is up \
                  and '{database}' is published (`lyracore dev status`), and that its module is \
                  current — `game_package_import` only exists once the Package artifact apply stage \
                  has been published to this Shard."
@@ -225,7 +215,7 @@ fn read_base_stamp(
 /// Matches when every enabled Package is recorded with a matching digest, no other Package is
 /// recorded, and — when `base` is `Some` — every row sits on the Shard's current base stamp (a claim
 /// recorded against a replaced import is stale; the script family has no base import, so it passes
-/// `None`). Any mismatch means replay; a total match returns the reason it is complete.
+/// `None`). Any mismatch means apply; a total match returns the reason it is complete.
 fn already_complete(
     family: &str,
     digests: &[(&str, &str)],
@@ -306,8 +296,8 @@ fn refusal(error: &Error) -> String {
 }
 
 /// The command that resumes this run — the same one, because resume is what re-running does.
-fn resume_command(shards: &[String], options: &ReplayOptions) -> String {
-    let mut line = format!("lyracore packages replay {}", shards.join(" "));
+fn resume_command(shards: &[String], options: &ApplyOptions) -> String {
+    let mut line = format!("lyracore packages apply {}", shards.join(" "));
     if let Some(path) = &options.client_data {
         line.push_str(&format!(" --client-data {path}"));
     }
@@ -320,12 +310,12 @@ fn resume_command(shards: &[String], options: &ReplayOptions) -> String {
     line
 }
 
-/// Replay every enabled Package's Delta across the named Shards.
+/// Apply every enabled Package's Delta across the named Shards.
 pub fn run(
     project: &ProjectLayout,
     runner: &dyn ProcessRunner,
     prompt: &dyn Prompt,
-    options: &ReplayOptions,
+    options: &ApplyOptions,
 ) -> Result<()> {
     let shards = if options.databases.is_empty() {
         recorded_databases(project)?
@@ -334,11 +324,16 @@ pub fn run(
     };
     if shards.is_empty() {
         return Err(Error::Usage(
-            "no Shard to replay onto. Name the databases explicitly, e.g. `lyracore packages \
-             replay lyracore lyracore-kalimdor`."
+            "no Shard to apply onto. Name the databases explicitly, e.g. `lyracore packages \
+             apply lyracore lyracore-kalimdor`."
                 .to_string(),
         ));
     }
+    databases(&shards)?;
+    check::prepare(project, runner, prompt, options.client_data.as_deref())?;
+    let has_rust = inventory(project)?
+        .iter()
+        .any(|package| package.dir.join("src/mod.rs").is_file());
 
     // ---- preflight: the artifacts, once, before any target is touched ----
     let root = project.packages_dir();
@@ -348,7 +343,7 @@ pub fn run(
     let conflicts = artifact::conflicts(artifacts);
     if !conflicts.is_empty() {
         return Err(Error::Usage(format!(
-            "{} claim conflict(s) between enabled Packages — nothing was replayed:\n{}\nResolve \
+            "{} claim conflict(s) between enabled Packages — nothing was applied:\n{}\nResolve \
              them by disabling a Package (`lyracore packages disable NAME`) or by changing what one \
              of them claims. The module refuses the same plan.",
             conflicts.len(),
@@ -362,7 +357,7 @@ pub fn run(
     let collisions = script::collisions(scripts);
     if !collisions.is_empty() {
         return Err(Error::Usage(format!(
-            "{} Runtime Script collision(s) between enabled Packages — nothing was replayed:\n{}\n\
+            "{} Runtime Script collision(s) between enabled Packages — nothing was applied:\n{}\n\
              A script belongs to one Package outright, so there is nothing to merge and no priority \
              to break the tie with. Resolve them by disabling a Package (`lyracore packages disable \
              NAME`) or by renumbering or renaming one script. The module refuses the same plan.",
@@ -417,7 +412,17 @@ pub fn run(
     let delta_digests = delta_digests(artifacts);
     let script_digests = script_digests(scripts);
     let mut targets = Vec::with_capacity(shards.len());
+    let mut publish_shards = Vec::new();
     for database in &shards {
+        let teardown = ask(
+            project,
+            runner,
+            database,
+            "SELECT package_name FROM game_package_teardown",
+        )?;
+        if has_rust || !rows(&teardown, &["package_name"]).is_empty() {
+            publish_shards.push(database.clone());
+        }
         let spell_rows = read_spell_provenance(project, runner, database)?;
         let base = read_base_stamp(project, runner, database, SPELL_FAMILY)?;
         let script_rows = read_script_provenance(project, runner, database)?;
@@ -437,6 +442,12 @@ pub fn run(
         report_target(&target);
         targets.push(target);
     }
+    if !publish_shards.is_empty() {
+        println!(
+            "  publish Module and repair schedules: {}",
+            shard_list(&publish_shards)
+        );
+    }
 
     let wanted: Vec<&Target> = targets.iter().filter(|t| t.wanted()).collect();
     let skipped: Vec<String> = targets
@@ -460,6 +471,10 @@ pub fn run(
     };
 
     if options.check {
+        if !publish_shards.is_empty() {
+            preflight::run(project, runner)?;
+            publish::require_loot_roll_upgrade_ready(project, runner, &publish_shards)?;
+        }
         println!();
         println!("=== check: the plan, per Shard, writing nothing ===");
         if spell_check_wanted {
@@ -475,7 +490,7 @@ pub fn run(
                             .to_string(),
                     )
                 })?;
-                runner.run_streaming(&replay_command(
+                runner.run_streaming(&apply_command(
                     project,
                     &target.database,
                     client_data,
@@ -491,11 +506,11 @@ pub fn run(
             );
         }
         println!();
-        println!("check only — nothing was written. Re-run without --check to apply.");
+        println!("check only: no Realm changes. Re-run without --check to apply.");
         return Ok(());
     }
 
-    if wanted.is_empty() {
+    if wanted.is_empty() && publish_shards.is_empty() {
         println!();
         println!(
             "every named Shard already holds these {} Package Delta(s) on its current base import, \
@@ -504,16 +519,27 @@ pub fn run(
             script_count(scripts),
             shard_list(&skipped)
         );
-        println!("nothing to replay. Use --force-all to reapply anyway.");
+        println!("nothing to apply. Use --force-all to reapply anyway.");
         return Ok(());
     }
 
     let pending: Vec<String> = wanted.iter().map(|t| t.database.clone()).collect();
+    let mut confirmation = if wanted.is_empty() {
+        String::new()
+    } else {
+        question(&wanted, artifacts, scripts, &pending)
+    };
+    if !publish_shards.is_empty() {
+        confirmation = format!(
+            "Publish this checkout's Module and repair schedules on {}. {confirmation}",
+            shard_list(&publish_shards)
+        );
+    }
     println!();
     crate::cmd::packages::confirm(
         prompt,
-        &question(&wanted, artifacts, scripts, &pending),
-        "Nothing was replayed.",
+        &format!("{confirmation} Proceed?"),
+        "Nothing was applied.",
         options.yes,
     )?;
 
@@ -522,18 +548,45 @@ pub fn run(
     if wanted.iter().any(|t| t.spell.is_none()) {
         runner.run_streaming(&import::build_importer_command(project))?;
     }
+    if !publish_shards.is_empty() {
+        preflight::run(project, runner)?;
+        publish::require_loot_roll_upgrade_ready(project, runner, &publish_shards)?;
+    }
 
     let mut completed = Vec::new();
+    let mut published = Vec::new();
+    let pending_targets: Vec<_> = targets
+        .iter()
+        .filter(|target| target.wanted() || publish_shards.contains(&target.database))
+        .collect();
     let stop_context = StopContext {
         targets: &targets,
-        wanted: &wanted,
+        wanted: &pending_targets,
         shards: &shards,
         options,
     };
 
-    for (index, target) in wanted.iter().enumerate() {
+    for (index, target) in pending_targets.iter().enumerate() {
         println!();
-        println!("==> replaying {}", target.database);
+        println!("==> applying {}", target.database);
+        if publish_shards.contains(&target.database) {
+            publish::publish_and_repair(project, runner, &target.database).map_err(|error| {
+                let remaining: Vec<_> = pending_targets[index + 1..]
+                    .iter()
+                    .map(|target| target.database.clone())
+                    .collect();
+                Error::Process(format!(
+                    "{error}\n  Published and repaired: {}\n  Completed artifacts:\n    \
+                     spell: {}\n    script: {}\n  Not attempted: {}\n  Retry with:\n    {}",
+                    shard_list(&published),
+                    shard_list(&completed_in(&completed, SPELL_FAMILY)),
+                    shard_list(&completed_in(&completed, SCRIPT_FAMILY)),
+                    shard_list(&remaining),
+                    resume_command(&shards, options)
+                ))
+            })?;
+            published.push(target.database.clone());
+        }
 
         match &target.spell {
             Some(reason) => println!("  {SPELL_FAMILY}: already complete — {reason}"),
@@ -544,7 +597,7 @@ pub fn run(
                             .to_string(),
                     )
                 })?;
-                let command = replay_command(project, &target.database, client_data, true)?;
+                let command = apply_command(project, &target.database, client_data, true)?;
                 if let Err(error) = runner.run_streaming(&command) {
                     return Err(stopped(
                         &target.database,
@@ -552,6 +605,7 @@ pub fn run(
                         index,
                         &error.to_string(),
                         &completed,
+                        &published,
                         &stop_context,
                     ));
                 }
@@ -575,6 +629,7 @@ pub fn run(
                         index,
                         &refusal(&error),
                         &completed,
+                        &published,
                         &stop_context,
                     ));
                 }
@@ -584,10 +639,14 @@ pub fn run(
     }
 
     println!();
-    println!("replayed:");
+    println!(
+        "Module published and schedules repaired: {}",
+        shard_list(&published)
+    );
+    println!("applied artifacts:");
     println!(
         "{}",
-        replayed(
+        applied(
             SPELL_FAMILY,
             &format!("{} enabled Package Delta(s)", artifacts.len()),
             &written(&wanted, |t| t.spell.is_none()),
@@ -595,7 +654,7 @@ pub fn run(
     );
     println!(
         "{}",
-        replayed(
+        applied(
             SCRIPT_FAMILY,
             &format!(
                 "{} Runtime Script(s) from {} Package(s)",
@@ -607,7 +666,7 @@ pub fn run(
     );
     if !skipped.is_empty() {
         println!(
-            "already complete in both families, untouched: {}",
+            "artifact families already complete: {}",
             shard_list(&skipped)
         );
     }
@@ -618,10 +677,10 @@ struct StopContext<'a, 'target> {
     targets: &'a [Target],
     wanted: &'a [&'target Target],
     shards: &'a [String],
-    options: &'a ReplayOptions,
+    options: &'a ApplyOptions,
 }
 
-/// Report a stopped replay by Import Family, including a family that completed on the Shard where
+/// Report a stopped apply by Import Family, including a family that completed on the Shard where
 /// a later family refused its plan.
 fn stopped(
     failed: &str,
@@ -629,6 +688,7 @@ fn stopped(
     index: usize,
     cause: &str,
     completed: &[(String, &'static str)],
+    published: &[String],
     context: &StopContext<'_, '_>,
 ) -> Error {
     let completed_spell = completed_in(completed, SPELL_FAMILY);
@@ -641,13 +701,14 @@ fn stopped(
         .collect::<Vec<_>>();
 
     Error::Process(format!(
-        "{cause}\n  replay stopped at: {failed} ({family} family)\n  completed this run:\n    \
+        "{cause}\n  Module published and schedules repaired: {published}\n  apply stopped at: {failed} ({family} family)\n  completed this run:\n    \
          {SPELL_FAMILY}: {completed_spell}\n    {SCRIPT_FAMILY}: {completed_script}\n  already complete \
          before this run:\n    {SPELL_FAMILY}: {skipped_spell}\n    {SCRIPT_FAMILY}: \
-         {skipped_script}\n  untouched Shards: {untouched}\n\n  The failed Shard wrote nothing \
-         for the {family} family. That apply is one transaction, so it lands whole or not at all. \
-         Any family that completed earlier stays applied. Fix the cause and re-run the SAME command. \
+         {skipped_script}\n  unattempted artifact Shards: {untouched}\n\n  Earlier completed \
+         families stay applied. Script reconciliation is one transaction. A failed spell import \
+         may already have replaced base rows. Fix the cause and re-run the SAME command. \
          Provenance makes completed families skip:\n    {resume}",
+        published = shard_list(published),
         completed_spell = shard_list(&completed_spell),
         completed_script = shard_list(&completed_script),
         skipped_spell = shard_list(&skipped_spell),
@@ -684,7 +745,7 @@ fn written(wanted: &[&Target], needed: impl Fn(&Target) -> bool) -> Vec<String>
 
 /// One family's closing line: what it applied and where, or that it had nothing to do. A family
 /// every named Shard already held must not read as a family this run reapplied.
-fn replayed(family: &str, what: &str, written: &[String]) -> String {
+fn applied(family: &str, what: &str, written: &[String]) -> String {
     if written.is_empty() {
         format!("  {family}: nothing — every named Shard was already complete")
     } else {
@@ -701,7 +762,7 @@ fn report_target(target: &Target) {
     ] {
         let state = match complete {
             Some(reason) => format!("already complete — {reason}"),
-            None => "replay".to_string(),
+            None => "apply".to_string(),
         };
         // The Shard is named once, on the first line, so two families of one Shard read as one
         // entry rather than two.
@@ -735,7 +796,7 @@ fn question(
                 .to_string()
         } else {
             format!(
-                "reimport Spell.dbc and replay {} enabled Package Delta(s) over it",
+                "reimport Spell.dbc and apply {} enabled Package Delta(s) over it",
                 artifacts.len()
             )
         });
@@ -753,7 +814,7 @@ fn question(
         });
     }
     format!(
-        "Replaying will {} on {}. Proceed?",
+        "Applying will {} on {}.",
         clauses.join(", and "),
         shard_list(pending)
     )
@@ -789,6 +850,12 @@ mod tests {
                 std::fs::write(data.join(archive), "").unwrap();
             }
             let project = ProjectLayout::from_root(root).unwrap();
+            std::fs::create_dir_all(project.datascripts_dir()).unwrap();
+            for name in ["tsconfig.json", "package.json", "bun.lock"] {
+                std::fs::write(project.datascripts_dir().join(name), "{}").unwrap();
+            }
+            std::fs::create_dir_all(project.datascript_types_dir()).unwrap();
+            std::fs::write(project.base_snapshot_file(), "{}").unwrap();
             Self { tmp, project }
         }
 
@@ -816,6 +883,14 @@ mod tests {
                 ),
             )
             .unwrap();
+            for artifact in self
+                .enabled()
+                .deltas
+                .iter()
+                .filter(|a| a.package == package)
+            {
+                super::super::identity::write(&self.project, artifact).unwrap();
+            }
             self
         }
 
@@ -858,8 +933,8 @@ mod tests {
             script::pack(&self.enabled().scripts)
         }
 
-        fn options(&self, shards: &[&str]) -> ReplayOptions {
-            ReplayOptions {
+        fn options(&self, shards: &[&str]) -> ApplyOptions {
+            ApplyOptions {
                 databases: shards.iter().map(|s| (*s).to_string()).collect(),
                 client_data: Some(self.client_data()),
                 yes: true,
@@ -867,8 +942,8 @@ mod tests {
             }
         }
 
-        fn options_without_client_data(&self, shards: &[&str]) -> ReplayOptions {
-            ReplayOptions {
+        fn options_without_client_data(&self, shards: &[&str]) -> ApplyOptions {
+            ApplyOptions {
                 databases: shards.iter().map(|s| (*s).to_string()).collect(),
                 yes: true,
                 ..Default::default()
@@ -983,7 +1058,7 @@ mod tests {
     // ---- the run ----
 
     #[test]
-    fn every_named_shard_is_replayed_in_order() {
+    fn every_named_shard_is_applied_in_order() {
         let checkout = Checkout::new();
         checkout.with_package("bolt", 133, 1500);
         let mut stack = FakeStack::new();
@@ -1038,7 +1113,7 @@ mod tests {
         let message = error.to_string();
         assert_eq!(error.exit_code(), crate::error::EXIT_FAILURE);
         assert!(
-            message.contains("replay stopped at: lyracore-kalimdor"),
+            message.contains("apply stopped at: lyracore-kalimdor"),
             "{message}"
         );
         assert!(
@@ -1046,12 +1121,12 @@ mod tests {
             "{message}"
         );
         assert!(
-            message.contains("untouched Shards: lyracore-instances"),
+            message.contains("unattempted artifact Shards: lyracore-instances"),
             "{message}"
         );
         assert!(
             message
-                .contains("lyracore packages replay lyracore lyracore-kalimdor lyracore-instances"),
+                .contains("lyracore packages apply lyracore lyracore-kalimdor lyracore-instances"),
             "the resume command is the same command: {message}"
         );
         assert!(
@@ -1098,7 +1173,7 @@ mod tests {
         checkout.with_package("bolt", 133, 1500);
         let hash = checkout.artifact_hash("bolt");
         let stack = applied_shard(FakeStack::new(), "lyracore-kalimdor", "bolt", &hash);
-        let options = ReplayOptions {
+        let options = ApplyOptions {
             force_all: true,
             ..checkout.options(&["lyracore-kalimdor"])
         };
@@ -1117,7 +1192,7 @@ mod tests {
     /// A Shard stamped from a DIFFERENT base import is not complete, whatever its artifact digests
     /// say: the claims sit on rows the base import has since replaced.
     #[test]
-    fn a_shard_on_a_different_base_import_is_replayed_even_though_its_digests_match() {
+    fn a_shard_on_a_different_base_import_is_applied_even_though_its_digests_match() {
         let checkout = Checkout::new();
         checkout.with_package("bolt", 133, 1500);
         let hash = checkout.artifact_hash("bolt");
@@ -1142,12 +1217,12 @@ mod tests {
         assert_eq!(applies(&stack).len(), 1, "{:?}", applies(&stack));
     }
 
-    /// Removing a Package must replay every affected target with the REMAINING set. The payload is
+    /// Removing a Package must apply every affected target with the REMAINING set. The payload is
     /// built by the importer from the enabled inventory, so the proof is that the disabled
     /// Package's artifact is no longer in the tree the importer is pointed at, and that the Shard
     /// still holding its provenance row is not treated as complete.
     #[test]
-    fn a_shard_still_recording_a_disabled_package_is_replayed_with_the_remaining_set() {
+    fn a_shard_still_recording_a_disabled_package_is_applied_with_the_remaining_set() {
         let checkout = Checkout::new();
         checkout.with_package("bolt", 133, 1500);
         let bolt = checkout.artifact_hash("bolt");
@@ -1177,7 +1252,7 @@ mod tests {
         assert_eq!(
             applied.len(),
             1,
-            "an extra provenance row forces a replay: {applied:?}"
+            "an extra provenance row forces a apply: {applied:?}"
         );
         assert!(
             !std::fs::read_dir(checkout.project.packages_dir())
@@ -1195,7 +1270,7 @@ mod tests {
         for shard in ["lyracore", "lyracore-kalimdor"] {
             stack = fresh_shard(stack, shard);
         }
-        let options = ReplayOptions {
+        let options = ApplyOptions {
             check: true,
             yes: false,
             ..checkout.options(&["lyracore", "lyracore-kalimdor"])
@@ -1227,7 +1302,7 @@ mod tests {
         checkout.with_package("bolt", 133, 1500);
         let hash = checkout.artifact_hash("bolt");
         let stack = applied_shard(FakeStack::new(), "lyracore-kalimdor", "bolt", &hash);
-        let options = ReplayOptions {
+        let options = ApplyOptions {
             check: true,
             ..checkout.options(&["lyracore-kalimdor"])
         };
@@ -1253,7 +1328,7 @@ mod tests {
     /// importer clears the Package spell range for it. It must never be an accident, so the
     /// confirmation names the consequence rather than counting Packages.
     #[test]
-    fn an_empty_enabled_inventory_states_what_it_clears_before_it_replays() {
+    fn an_empty_enabled_inventory_states_what_it_clears_before_it_applies() {
         let checkout = Checkout::new();
         // Nothing enabled, but the Shard still records a Package from an earlier run.
         let stack = applied_shard(FakeStack::new(), "lyracore", "bolt", "stale-digest");
@@ -1263,7 +1338,7 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &prompt,
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options(&["lyracore"])
             },
@@ -1296,7 +1371,7 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &ScriptedPrompt::new(&[]),
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options(&["lyracore"])
             },
@@ -1324,8 +1399,11 @@ mod tests {
         assert_eq!(error.exit_code(), crate::error::EXIT_USAGE);
         assert!(error.to_string().contains("claim conflict"), "{error}");
         assert!(
-            stack.rendered().is_empty(),
-            "nothing may run before the artifacts are cleared: {:?}",
+            stack
+                .rendered()
+                .iter()
+                .all(|call| !call.contains("spacetime sql")),
+            "no Shard may be read before the artifacts are cleared: {:?}",
             stack.rendered()
         );
     }
@@ -1354,7 +1432,7 @@ mod tests {
     }
 
     #[test]
-    fn a_refused_confirmation_replays_nothing() {
+    fn a_refused_confirmation_applies_nothing() {
         let checkout = Checkout::new();
         checkout.with_package("bolt", 133, 1500);
         let stack = fresh_shard(FakeStack::new(), "lyracore");
@@ -1363,17 +1441,14 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &ScriptedPrompt::new(&["no"]),
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options(&["lyracore"])
             },
         )
         .unwrap_err();
 
-        assert!(
-            error.to_string().contains("Nothing was replayed"),
-            "{error}"
-        );
+        assert!(error.to_string().contains("Nothing was applied"), "{error}");
         assert!(applies(&stack).is_empty(), "{:?}", stack.rendered());
     }
 
@@ -1396,8 +1471,8 @@ mod tests {
             .into_iter()
             .filter(|r| r.contains("spacetime sql"))
             .collect();
-        // The spell family's base stamp and provenance, then the script family's provenance.
-        assert_eq!(queries.len(), 3, "{queries:?}");
+        // Package Teardown and each artifact family are read before writes.
+        assert_eq!(queries.len(), 4, "{queries:?}");
         for query in &queries {
             assert!(!query.contains("ORDER BY"), "{query}");
             assert!(!query.contains(" IN ("), "{query}");
@@ -1514,7 +1589,7 @@ mod tests {
             "bolt",
             &hash,
         );
-        let options = ReplayOptions {
+        let options = ApplyOptions {
             force_all: true,
             ..checkout.options(&["lyracore"])
         };
@@ -1547,7 +1622,7 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &prompt,
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options(&["lyracore"])
             },
@@ -1581,7 +1656,7 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &ScriptedPrompt::new(&[]),
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options(&["lyracore"])
             },
@@ -1615,7 +1690,7 @@ mod tests {
         let message = error.to_string();
         assert_eq!(error.exit_code(), crate::error::EXIT_FAILURE);
         assert!(
-            message.contains("replay stopped at: lyracore-kalimdor (script family)"),
+            message.contains("apply stopped at: lyracore-kalimdor (script family)"),
             "{message}"
         );
         assert!(message.contains("nothing applied"), "{message}");
@@ -1624,7 +1699,7 @@ mod tests {
             "{message}"
         );
         assert!(
-            message.contains("untouched Shards: lyracore-instances"),
+            message.contains("unattempted artifact Shards: lyracore-instances"),
             "{message}"
         );
         assert!(
@@ -1682,8 +1757,11 @@ mod tests {
             "{error}"
         );
         assert!(
-            stack.rendered().is_empty(),
-            "nothing may run before the artifacts are cleared: {:?}",
+            stack
+                .rendered()
+                .iter()
+                .all(|call| !call.contains("spacetime sql")),
+            "no Shard may be read before the artifacts are cleared: {:?}",
             stack.rendered()
         );
     }
@@ -1694,7 +1772,7 @@ mod tests {
         checkout.with_script("bolt", 100_001, "bolt.greet");
         checkout.remove_client_data();
         let stack = fresh_shard(FakeStack::new(), "lyracore");
-        let options = ReplayOptions {
+        let options = ApplyOptions {
             check: true,
             yes: false,
             ..checkout.options_without_client_data(&["lyracore"])
@@ -1764,7 +1842,7 @@ mod tests {
             &checkout.project,
             &stack.runner(),
             &ScriptedPrompt::new(&[]),
-            &ReplayOptions {
+            &ApplyOptions {
                 yes: false,
                 ..checkout.options_without_client_data(&["lyracore"])
             },
@@ -1805,7 +1883,7 @@ mod tests {
             "{message}"
         );
         assert!(
-            message.contains("Any family that completed earlier stays applied."),
+            message.contains("Earlier completed families stay applied."),
             "{message}"
         );
     }
@@ -1814,7 +1892,7 @@ mod tests {
     /// and none of its Runtime Scripts, which is what every Realm looks like the first time a
     /// Package ships a script.
     #[test]
-    fn a_shard_complete_for_one_family_is_still_replayed_for_the_other() {
+    fn a_shard_complete_for_one_family_is_still_applied_for_the_other() {
         let checkout = Checkout::new();
         checkout.with_package("bolt", 133, 1500);
         checkout.with_script("bolt", 100_001, "bolt.greet");
@@ -1841,4 +1919,444 @@ mod tests {
             stack.rendered()
         );
     }
+    impl Checkout {
+        fn with_module(&self) -> &Self {
+            use crate::proc::fake::{FAKE_RUST_VERSION, FAKE_SPACETIME_VERSION};
+            let root = &self.project.root;
+            std::fs::write(
+                root.join(ProjectLayout::RUST_TOOLCHAIN),
+                format!("[toolchain]\nchannel = \"{FAKE_RUST_VERSION}\"\n"),
+            )
+            .unwrap();
+            std::fs::create_dir_all(root.join("module/src")).unwrap();
+            std::fs::write(
+                root.join("module/Cargo.toml"),
+                format!("spacetimedb = {{ version = \"={FAKE_SPACETIME_VERSION}\" }}\n"),
+            )
+            .unwrap();
+            std::fs::write(root.join("module/src/lib.rs"),
+                "#[client_visibility_filter]\nconst RLS: Filter = Filter::Sql(\"SELECT * FROM game_character WHERE owner_identity = :sender\");\n").unwrap();
+            self
+        }
+
+        fn with_rust(&self) -> &Self {
+            self.with_module();
+            let dir = self.project.packages_dir().join("greeter/src");
+            std::fs::create_dir_all(&dir).unwrap();
+            std::fs::write(dir.join("mod.rs"), "pub fn register() {}\n").unwrap();
+            self
+        }
+
+        fn with_script_source(&self) -> &Self {
+            let dir = self.project.package_scripts_dir("greeter");
+            std::fs::create_dir_all(&dir).unwrap();
+            std::fs::write(
+                dir.join("welcome.ts"),
+                "// @id 100300\n// @event on_login\n",
+            )
+            .unwrap();
+            self
+        }
+    }
+
+    /// Substitutes only the compiler and snapshot extractor subprocesses. Artifact discovery,
+    /// Build Identity checks, preparation, and activation use the real command implementation.
+    struct PackageCompiler<'a> {
+        checkout: &'a Checkout,
+        stack: FakeStack,
+    }
+
+    impl ProcessRunner for PackageCompiler<'_> {
+        fn run_and_wait(&self, cmd: &CommandSpec) -> Result<String> {
+            self.stack.runner().run_and_wait(cmd)
+        }
+        fn run_capturing_stderr(&self, cmd: &CommandSpec) -> Result<String> {
+            self.stack.runner().run_capturing_stderr(cmd)
+        }
+        fn run_with_secret_stdin(&self, cmd: &CommandSpec, secret: &[u8]) -> Result<String> {
+            self.stack.runner().run_with_secret_stdin(cmd, secret)
+        }
+        fn spawn_logged(&self, cmd: &CommandSpec, log: &Path) -> Result<u32> {
+            self.stack.runner().spawn_logged(cmd, log)
+        }
+        fn terminate(&self, pid: u32) -> Result<()> {
+            self.stack.runner().terminate(pid)
+        }
+        fn run_streaming(&self, cmd: &CommandSpec) -> Result<()> {
+            self.stack.runner().run_streaming(cmd)?;
+            if cmd.args().iter().any(|arg| arg == "--spell-snapshot") {
+                std::fs::write(self.checkout.project.base_snapshot_file(), "{}")?;
+            }
+            if cmd.program() == "bun" {
+                if cmd
+                    .args()
+                    .iter()
+                    .any(|arg| arg.ends_with("build-scripts.ts"))
+                {
+                    self.checkout
+                        .with_script("greeter", 100300, "greeter.login");
+                    std::fs::rename(
+                        self.checkout.generated("greeter").join("script.json"),
+                        self.checkout
+                            .generated("greeter")
+                            .join("greeter.script.json"),
+                    )?;
+                }
+                if cmd
+                    .args()
+                    .iter()
+                    .any(|arg| arg.ends_with("datascripts/spells.ts"))
+                {
+                    self.checkout.with_package("greeter", 133, 2000);
+                }
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn missing_script_artifacts_build_and_activate_in_one_command() {
+        let checkout = Checkout::new();
+        checkout.with_script_source();
+        let stack = FakeStack::new().with_stdout("bun --version", "1.3.7");
+        run(
+            &checkout.project,
+            &PackageCompiler {
+                checkout: &checkout,
+                stack: stack.clone(),
+            },
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one"]),
+        )
+        .unwrap();
+        assert_eq!(checkout.enabled().scripts.len(), 1);
+        assert!(
+            script::stale(&checkout.project, &checkout.enabled().script_paths())
+                .unwrap()
+                .is_empty()
+        );
+        assert!(script_applies(&stack)[0].contains("greeter.login"));
+        assert!(!stack
+            .rendered()
+            .iter()
+            .any(|call| call.contains("spacetime publish")));
+    }
+
+    #[test]
+    fn changed_script_sources_rebuild_before_activation() {
+        let checkout = Checkout::new();
+        checkout
+            .with_script_source()
+            .with_script("greeter", 100299, "greeter.old");
+        super::super::identity::write_script_identities(
+            &checkout.project,
+            &checkout.enabled().script_paths(),
+        )
+        .unwrap();
+        std::fs::write(
+            checkout
+                .project
+                .package_scripts_dir("greeter")
+                .join("welcome.ts"),
+            "// changed\n",
+        )
+        .unwrap();
+        let stack = FakeStack::new().with_stdout("bun --version", "1.3.7");
+        run(
+            &checkout.project,
+            &PackageCompiler {
+                checkout: &checkout,
+                stack: stack.clone(),
+            },
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one"]),
+        )
+        .unwrap();
+        assert!(script_applies(&stack)[0].contains("greeter.login"));
+        assert!(!script_applies(&stack)[0].contains("greeter.old"));
+    }
+
+    #[test]
+    fn current_source_built_scripts_need_neither_bun_nor_publish() {
+        let checkout = Checkout::new();
+        checkout
+            .with_script_source()
+            .with_script("greeter", 100300, "greeter.login");
+        super::super::identity::write_script_identities(
+            &checkout.project,
+            &checkout.enabled().script_paths(),
+        )
+        .unwrap();
+        let stack = FakeStack::new();
+        run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one"]),
+        )
+        .unwrap();
+        assert_eq!(script_applies(&stack).len(), 1);
+        assert!(stack.rendered().iter().all(|call| !call.starts_with("bun ")
+            && !call.contains("spacetime publish")
+            && !call.contains("spacetime generate")));
+    }
+
+    #[test]
+    fn datascript_sources_extract_a_missing_snapshot_then_build_and_apply() {
+        let checkout = Checkout::new();
+        let dir = checkout.project.packages_dir().join("greeter/datascripts");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("spells.ts"), "// trusted Datascript\n").unwrap();
+        std::fs::remove_file(checkout.project.base_snapshot_file()).unwrap();
+        let stack = FakeStack::new().with_stdout("bun --version", "1.3.7");
+        run(
+            &checkout.project,
+            &PackageCompiler {
+                checkout: &checkout,
+                stack: stack.clone(),
+            },
+            &ScriptedPrompt::new(&[]),
+            &checkout.options(&["one"]),
+        )
+        .unwrap();
+        assert!(checkout.project.base_snapshot_file().is_file());
+        assert_eq!(checkout.enabled().deltas.len(), 1);
+        assert_eq!(applies(&stack).len(), 1);
+    }
+
+    #[test]
+    fn a_build_failure_leaves_every_shard_untouched() {
+        let checkout = Checkout::new();
+        checkout.with_script_source();
+        let stack = FakeStack::new()
+            .with_stdout("bun --version", "1.3.7")
+            .fail_on("build-scripts.ts", "invalid event");
+        let error = run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one"]),
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("invalid event"), "{error}");
+        assert!(!stack
+            .rendered()
+            .iter()
+            .any(|call| call.starts_with("spacetime sql")
+                || call.starts_with("spacetime call")
+                || call.starts_with("spacetime publish")));
+    }
+
+    #[test]
+    fn rust_packages_publish_and_repair_each_shard_even_without_artifacts() {
+        let checkout = Checkout::new();
+        checkout.with_rust();
+        let stack = FakeStack::new();
+        run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one", "two"]),
+        )
+        .unwrap();
+        let writes: Vec<_> = stack
+            .rendered()
+            .into_iter()
+            .filter(|call| {
+                call.starts_with("spacetime publish") || call.contains("debug_repair_after_publish")
+            })
+            .collect();
+        assert_eq!(writes.len(), 4, "{writes:?}");
+        assert!(writes[0].ends_with("one") && writes[1].contains("one debug_repair_after_publish"));
+        assert!(writes[2].ends_with("two") && writes[3].contains("two debug_repair_after_publish"));
+    }
+
+    #[test]
+    fn pending_teardown_publishes_after_the_last_rust_folder_was_removed() {
+        let checkout = Checkout::new();
+        checkout.with_module();
+        let stack = FakeStack::new().with_stdout(
+            "SELECT package_name FROM game_package_teardown",
+            " package_name\n greeter\n",
+        );
+        run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one"]),
+        )
+        .unwrap();
+        assert!(stack
+            .rendered()
+            .iter()
+            .any(|call| call.starts_with("spacetime publish")));
+    }
+
+    #[test]
+    fn check_and_declined_confirmation_never_publish_rust_packages() {
+        for check in [false, true] {
+            let checkout = Checkout::new();
+            checkout.with_rust();
+            let stack = FakeStack::new();
+            let mut options = checkout.options_without_client_data(&["one"]);
+            options.check = check;
+            options.yes = false;
+            let result = run(
+                &checkout.project,
+                &stack.runner(),
+                &ScriptedPrompt::new(&["no"]),
+                &options,
+            );
+            assert_eq!(result.is_ok(), check, "{result:?}");
+            assert!(!stack
+                .rendered()
+                .iter()
+                .any(|call| call.starts_with("spacetime publish")
+                    || call.starts_with("spacetime call")));
+        }
+    }
+
+    #[test]
+    fn publish_failure_keeps_prior_shards_complete_and_stops() {
+        let checkout = Checkout::new();
+        checkout
+            .with_rust()
+            .with_script("greeter", 100300, "greeter.login");
+        let stack = FakeStack::new().fail_on("--yes two", "migration refused");
+        let error = run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one", "two", "three"]),
+        )
+        .unwrap_err();
+        let message = error.to_string();
+        assert!(
+            message.contains("Published and repaired: one")
+                && message.contains("Not attempted: three"),
+            "{message}"
+        );
+        assert!(stack
+            .rendered()
+            .iter()
+            .any(|call| call.contains("one debug_repair_after_publish")));
+        assert_eq!(script_applies(&stack).len(), 1);
+        assert!(
+            message.contains("lyracore packages apply one two three"),
+            "{message}"
+        );
+    }
+
+    #[test]
+    fn schedule_repair_failure_reports_the_published_shard_and_stops() {
+        let checkout = Checkout::new();
+        checkout.with_rust();
+        let stack = FakeStack::new().fail_on("one debug_repair_after_publish", "operator only");
+        let error = run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one", "two"]),
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("'one' was published, but schedule repair failed"),
+            "{error}"
+        );
+        assert!(!stack
+            .rendered()
+            .iter()
+            .any(|call| call.starts_with("spacetime publish") && call.ends_with("two")));
+    }
+    #[test]
+    fn artifact_failure_leaves_later_shards_unpublished() {
+        let checkout = Checkout::new();
+        checkout
+            .with_rust()
+            .with_script("greeter", 100300, "greeter.login");
+        let stack = FakeStack::new().fail_on("one apply_package_deltas", "script refused");
+        let error = run(
+            &checkout.project,
+            &stack.runner(),
+            &ScriptedPrompt::new(&[]),
+            &checkout.options_without_client_data(&["one", "two"]),
+        )
+        .unwrap_err();
+        let message = error.to_string();
+        assert!(
+            message.contains("Module published and schedules repaired: one"),
+            "{message}"
+        );
+        assert!(
+            message.contains("unattempted artifact Shards: two"),
+            "{message}"
+        );
+        assert!(!stack
+            .rendered()
+            .iter()
+            .any(|call| call.starts_with("spacetime publish") && call.ends_with("two")));
+    }
+
+    #[test]
+    fn script_build_preserves_a_source_free_delta_without_a_snapshot() {
+        let checkout = Checkout::new();
+        checkout
+            .with_package("imported", 133, 1500)
+            .with_script_source();
+        let sidecar = checkout
+            .generated("imported")
+            .join(super::super::identity::IDENTITY_FILE);
+        let identity = std::fs::read(&sidecar).unwrap();
+        std::fs::remove_file(checkout.project.base_snapshot_file()).unwrap();
+        let stack = FakeStack::new().with_stdout("bun --version", "1.3.7");
+        run(
+            &checkout.project,
+            &PackageCompiler {
+                checkout: &checkout,
+                stack: stack.clone(),
+            },
+            &ScriptedPrompt::new(&[]),
+            &checkout.options(&["one"]),
+        )
+        .unwrap();
+        assert_eq!(std::fs::read(sidecar).unwrap(), identity);
+        assert!(!checkout.project.base_snapshot_file().exists());
+        assert_eq!(applies(&stack).len(), 1);
+        assert_eq!(script_applies(&stack).len(), 1);
+    }
+
+    #[test]
+    fn a_new_snapshot_cannot_certify_a_source_free_delta() {
+        let checkout = Checkout::new();
+        std::fs::write(checkout.project.base_snapshot_file(), "snapshot A").unwrap();
+        checkout.with_package("imported", 134, 1500);
+        let sidecar = checkout
+            .generated("imported")
+            .join(super::super::identity::IDENTITY_FILE);
+        let identity = std::fs::read(&sidecar).unwrap();
+        std::fs::remove_file(checkout.project.base_snapshot_file()).unwrap();
+        let dir = checkout.project.packages_dir().join("greeter/datascripts");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("spells.ts"), "// new Datascript").unwrap();
+        let stack = FakeStack::new().with_stdout("bun --version", "1.3.7");
+        let error = run(
+            &checkout.project,
+            &PackageCompiler {
+                checkout: &checkout,
+                stack: stack.clone(),
+            },
+            &ScriptedPrompt::new(&[]),
+            &checkout.options(&["one"]),
+        )
+        .unwrap_err();
+        assert!(error.to_string().contains("Base Snapshot"), "{error}");
+        assert_eq!(std::fs::read(sidecar).unwrap(), identity);
+        assert!(applies(&stack).is_empty());
+        assert!(!stack
+            .rendered()
+            .iter()
+            .any(|call| call.starts_with("spacetime publish")));
+    }
 }
diff --git a/src/cmd/packages/artifact.rs b/src/cmd/packages/artifact.rs
index 89ccad6..234ff02 100644
--- a/src/cmd/packages/artifact.rs
+++ b/src/cmd/packages/artifact.rs
@@ -1,7 +1,7 @@
 //! The enabled Packages' generated Delta artifacts: what they claim, what they disagree about, and
 //! the digest the Shard records for each one.
 //!
-//! `packages replay` has to answer two questions before it writes to the first Shard: is this set of
+//! `packages apply` has to answer two questions before it writes to the first Shard: is this set of
 //! artifacts applicable at all, and does a Shard already hold exactly this set. Both are answered
 //! here, from the working tree, once per run.
 //!
@@ -132,7 +132,7 @@ pub struct Artifact {
 /// A Package ships every artifact kind it has into one `data/.generated/` directory, so the walk
 /// meets Script Artifacts as well as Package Deltas. They are a different artifact with a different
 /// applier and a different Import Family, so they are kept apart rather than merged: `packages
-/// replay` applies both, and every other caller wants only the Deltas.
+/// apply` applies both, and every other caller wants only the Deltas.
 #[derive(Debug, Clone, Default)]
 pub struct Enabled {
     /// Every Package Delta, ordered by Package folder then file name.
@@ -179,7 +179,7 @@ pub fn read_enabled(root: &Path) -> Result<Enabled> {
 ///
 /// This is an inventory for the trust review. It reads the Package Delta envelope and table names,
 /// while the core parser remains the authority for keys, columns, types, and claim policy. Script
-/// Artifacts use their full parser because each Runtime Script is already a supported replay unit.
+/// Artifacts use their full parser because each Runtime Script is already a supported artifact.
 pub fn summarize_package_artifacts(package: &Path) -> Result<ReviewArtifacts> {
     if !package.is_dir() {
         return Err(Error::Usage(format!(
diff --git a/src/cmd/packages/build.rs b/src/cmd/packages/build.rs
index 7c4ba5e..7245fc4 100644
--- a/src/cmd/packages/build.rs
+++ b/src/cmd/packages/build.rs
@@ -36,7 +36,7 @@
 //!    Package's generated artifacts TOGETHER, in one invocation, Package Deltas and Script
 //!    Artifacts alike. A Claim Conflict and a Runtime Script collision are both BETWEEN Packages,
 //!    so checking one artifact at a time could only ever prove that one artifact parses. This is
-//!    the authoritative Rust-side check — the same trace `packages replay` runs before it writes to
+//!    the authoritative Rust-side check — the same trace `packages apply` runs before it writes to
 //!    a Shard — so what a build just emitted is validated by the code that also decides whether it
 //!    may apply, not by a second, looser implementation of the same rules.
 //! 8. A Build Identity sidecar (`packages::identity`) is written next to each source-built artifact
@@ -143,7 +143,7 @@ fn verify_bun(runner: &dyn ProcessRunner) -> Result<()> {
 // ---- Datascript emission and validation ----
 
 /// Enabled Packages with entry scripts in either supported Datascript location.
-fn packages_with_datascripts(project: &ProjectLayout) -> Result<Vec<String>> {
+pub(crate) fn packages_with_datascripts(project: &ProjectLayout) -> Result<Vec<String>> {
     let packages_dir = project.packages_dir();
     if !packages_dir.is_dir() {
         return Ok(Vec::new());
@@ -280,12 +280,12 @@ fn run_datascripts(
 
 /// The Rust-side authoritative check: every enabled Package's generated artifacts, of both kinds,
 /// traced together in one `lyracore-delta-check` invocation. Discovered the same way `packages
-/// replay` discovers them — a folder listing, not a re-parse by this command — so build-time
-/// validation and replay-time preflight can never disagree about which files are in play.
+/// apply` discovers them — a folder listing, not a re-parse by this command — so build-time
+/// validation and apply-time preflight can never disagree about which files are in play.
 ///
 /// Returns what it discovered and validated, so step 8 can write each artifact's Build Identity
 /// without re-reading a tree this step just finished checking.
-fn validate_generated_artifacts(
+pub(crate) fn validate_generated_artifacts(
     project: &ProjectLayout,
     runner: &dyn ProcessRunner,
     transition: Option<&script::BuildArtifactTransition>,
@@ -430,6 +430,9 @@ pub fn run(project: &ProjectLayout, runner: &dyn ProcessRunner) -> Result<()> {
         );
     }
     if datascript_packages.is_empty() && script_packages.is_empty() {
+        if project.packages_dir().is_dir() {
+            validate_generated_artifacts(project, runner, None)?;
+        }
         return Ok(());
     }
 
@@ -466,7 +469,12 @@ pub fn run(project: &ProjectLayout, runner: &dyn ProcessRunner) -> Result<()> {
             return Err(error);
         }
     };
-    if let Err(error) = identity::write_all(project, &enabled.deltas) {
+    let identities = enabled
+        .deltas
+        .iter()
+        .filter(|delta| datascript_packages.contains(&delta.package))
+        .try_for_each(|delta| identity::write(project, delta));
+    if let Err(error) = identities {
         transition.rollback()?;
         return Err(error);
     }
@@ -522,7 +530,7 @@ mod tests {
 
     /// The artifact a Datascript's own `bun run` would have written. `FakeStack` records a `bun
     /// run` call but does not execute Bun, so a test that needs one on disk (to exercise step 6,
-    /// the validator) writes it directly — the same way `packages/replay.rs`'s tests do.
+    /// the validator) writes it directly — the same way `packages/apply.rs`'s tests do.
     fn with_generated_artifact(project: &ProjectLayout, package: &str) {
         let dir = project.packages_dir().join(package).join("data/.generated");
         std::fs::create_dir_all(&dir).unwrap();
@@ -1055,7 +1063,7 @@ mod tests {
         let enabled = artifact::read_enabled(&project.packages_dir()).unwrap();
         assert!(
             enabled.scripts.is_empty(),
-            "a later replay must see no old Lua"
+            "a later apply must see no old Lua"
         );
     }
 
diff --git a/src/cmd/packages/check.rs b/src/cmd/packages/check.rs
index baaadee..4270a5d 100644
--- a/src/cmd/packages/check.rs
+++ b/src/cmd/packages/check.rs
@@ -26,7 +26,7 @@
 //!
 //! A source-built artifact without a sidecar is stale. A source-free artifact without one is
 //! prebuilt Lua: there is no source tree in this checkout to compare, and an Operator can install
-//! and replay it without Bun.
+//! and apply it without Bun.
 
 use crate::cmd::packages::artifact::{self, Artifact};
 use crate::cmd::packages::build;
@@ -35,6 +35,92 @@ use crate::proc::ProcessRunner;
 use crate::project::ProjectLayout;
 use crate::{Error, Result};
 
+/// Prepare installed sources before applying them. Source-free Deltas must already have a
+/// current Build Identity; rebuilding another Package must not certify stale imported artifacts.
+pub(crate) fn prepare(
+    project: &ProjectLayout,
+    runner: &dyn ProcessRunner,
+    prompt: &dyn crate::cmd::import::Prompt,
+    client_data: Option<&str>,
+) -> Result<()> {
+    use crate::cmd::import;
+    use crate::proc::CommandSpec;
+
+    super::inventory(project)?;
+    script::refuse_stale_transition(project)?;
+    let enabled = artifact::read_enabled(&project.packages_dir())?;
+    let datascripts = build::packages_with_datascripts(project)?;
+    let scripts = script::packages_with_scripts(project)?;
+    let missing = || {
+        datascripts
+            .iter()
+            .any(|name| !enabled.deltas.iter().any(|a| &a.package == name))
+            || scripts
+                .iter()
+                .any(|name| !enabled.scripts.iter().any(|a| &a.package == name))
+    };
+    let mut rebuild = missing() || !script::stale(project, &enabled.script_paths())?.is_empty();
+    if !enabled.deltas.is_empty() {
+        runner.run_streaming(&build::typegen_command(project))?;
+        for delta in &enabled.deltas {
+            let (problems, _) = check_one(project, delta)?;
+            if problems.is_empty() {
+                continue;
+            }
+            if !datascripts.contains(&delta.package) {
+                return Err(Error::Process(format!(
+                    "cannot rebuild Package '{}': no Datascript source is installed.\n{}\n\
+                     Install current source or a current artifact before applying.",
+                    delta.package,
+                    problems.join("\n")
+                )));
+            }
+            rebuild = true;
+        }
+    }
+    if rebuild {
+        if !datascripts.is_empty() && !project.base_snapshot_file().is_file() {
+            let data = import::resolve_client_data(project, prompt, client_data)?;
+            runner.run_streaming(&import::build_importer_command(project))?;
+            runner.run_streaming(
+                &CommandSpec::new(project.importer_bin().display().to_string())
+                    .arg("--dbc")
+                    .arg(data.display().to_string())
+                    .arg("--spell-snapshot")
+                    .arg(project.base_snapshot_file().display().to_string())
+                    .cwd(project.root.clone()),
+            )?;
+        }
+        println!("preparing installed Package sources");
+        build::run(project, runner)?;
+        // A newly extracted Base Snapshot can reveal drift in a source-free Delta. Its identity
+        // was preserved by the build, so compare it again before any Realm write.
+        run(project, runner)?;
+        let built = artifact::read_enabled(&project.packages_dir())?;
+        for (names, emitted) in [
+            (
+                &datascripts,
+                built.deltas.iter().map(|a| &a.package).collect::<Vec<_>>(),
+            ),
+            (
+                &scripts,
+                built.scripts.iter().map(|a| &a.package).collect::<Vec<_>>(),
+            ),
+        ] {
+            for name in names {
+                if !emitted.contains(&name) {
+                    return Err(Error::Process(format!(
+                        "Package '{name}' built without emitting its artifact. Nothing was applied."
+                    )));
+                }
+            }
+        }
+    } else {
+        build::validate_generated_artifacts(project, runner, None)?;
+    }
+    Ok(())
+}
+
 /// One artifact's problems, and whether its Base Snapshot comparison had to be skipped.
 fn check_one(project: &ProjectLayout, artifact: &Artifact) -> Result<(Vec<String>, bool)> {
     let sidecar_path = artifact.path.with_file_name(identity::IDENTITY_FILE);
diff --git a/src/cmd/packages/config.rs b/src/cmd/packages/config.rs
index 3e0f76b..6ead157 100644
--- a/src/cmd/packages/config.rs
+++ b/src/cmd/packages/config.rs
@@ -366,7 +366,7 @@ fn set(
 
 /// A write that stopped part way through the Realm.
 ///
-/// Fail fast, never rollback — the rule `packages replay` already runs on, for the same reason: a
+/// Fail fast, never rollback — the rule `packages apply` already runs on, for the same reason: a
 /// Realm that reported success while half-written cannot be recovered from its own report, and one
 /// that named the Shard it stopped at can. Re-running the same command after the cause is fixed
 /// rewrites the Shards that already took the value, which changes nothing on them.
@@ -450,7 +450,7 @@ mod tests {
 
         /// A stack that was brought up in this topology. The gateway record is what makes the
         /// recorded topology count: with nothing recorded, the default sharded fixture is the
-        /// answer, which is the behaviour `publish` and `packages replay` already have.
+        /// answer, which is the behaviour `publish` and `packages apply` already have.
         fn with_topology(&self, topology: Topology) -> &Self {
             RuntimeState {
                 gateway: Some(ProcessRecord {
diff --git a/src/cmd/packages/git.rs b/src/cmd/packages/git.rs
index e4b2a94..5891d4d 100644
--- a/src/cmd/packages/git.rs
+++ b/src/cmd/packages/git.rs
@@ -426,31 +426,14 @@ fn update_one(
     preserved.discard();
 
     println!();
-    if compiled_in {
-        println!(
-            "'{name}' is at {} and preflight is green. Two steps remain, and this command runs \
-             neither:",
-            short(clone.revision())
-        );
-        println!("  lyracore publish       compile the new revision into the module and publish it to every database");
-    } else {
-        println!(
-            "'{name}' is at {} and preflight is green. It is disabled, so the module still does \
-             not compile it. Two steps remain, and this command runs neither:",
-            short(clone.revision())
-        );
+    println!(
+        "'{name}' is at {} and preflight is green.",
+        short(clone.revision())
+    );
+    if !compiled_in {
         println!("  lyracore packages enable {name}");
-        println!("  lyracore publish       compile the new revision into the module and publish it to every database");
-    }
-    if review.addons.is_empty() && review.client_overrides == 0 {
-        println!("  lyracore client sync   not needed: this Package ships no client content");
-    } else {
-        println!(
-            "  lyracore client sync   install its {} addon(s) and {} client override(s) into your client",
-            review.addons.len(),
-            review.client_overrides
-        );
     }
+    print!("{}", super::activation_steps(&package.dir));
     Ok(true)
 }
 
diff --git a/src/cmd/packages/identity.rs b/src/cmd/packages/identity.rs
index 1d40dcc..bac9999 100644
--- a/src/cmd/packages/identity.rs
+++ b/src/cmd/packages/identity.rs
@@ -20,7 +20,7 @@
 //! `PackageDelta::parse` (the engine crate `artifact.rs` mirrors) refuses an unknown member, and
 //! `game_package_import.artifact_hash` is BLAKE3 over exactly the artifact's four canonical fields.
 //! Folding the Build Identity into the artifact would move that hash on every Bun or tsconfig bump
-//! that changes nothing about what the artifact CLAIMS — and `packages replay` treats a moved hash
+//! that changes nothing about what the artifact CLAIMS — and `packages apply` treats a moved hash
 //! as a Shard needing every claim reapplied. The two questions ("what does this artifact say" and
 //! "is this artifact still current") stay two files for exactly that reason.
 //!
diff --git a/src/cmd/packages/lifecycle.rs b/src/cmd/packages/lifecycle.rs
index ba36d98..bc0e3cf 100644
--- a/src/cmd/packages/lifecycle.rs
+++ b/src/cmd/packages/lifecycle.rs
@@ -61,15 +61,8 @@ pub fn enable(project: &ProjectLayout, name: &str) -> Result<()> {
     print!("{moved}");
     print!("{}", super::provenance_report(package.stamp.as_ref()));
 
-    let review = TrustReview::scan(&destination)?;
     println!();
-    println!(
-        "'{}' is back in the build. Three steps remain, and this command ran none of them:",
-        name.as_str()
-    );
-    println!("  lyracore preflight     compile the module with the Package in it and run the offline gate");
-    println!("  lyracore publish       publish the rebuilt module to every database of this realm");
-    println!("  {}", client_sync_step(&review));
+    print!("{}", super::activation_steps(&destination));
     println!();
     println!(
         "undo this move with `lyracore packages disable {}`.",
@@ -129,28 +122,8 @@ pub fn disable(project: &ProjectLayout, realm: &Realm, name: &str, yes: bool) ->
     print!("{moved}");
     print!("{}", super::provenance_report(package.stamp.as_ref()));
 
-    let mut steps = vec![
-        "lyracore publish       publish the module WITHOUT the Package to every database of this \
-         realm"
-            .to_string(),
-    ];
-    if !review.runtime_scripts.is_empty() {
-        steps.push(
-            "lyracore packages replay\n                         remove the Package's Runtime Scripts from every Shard"
-                .to_string(),
-        );
-    }
-    steps.push(client_sync_step(&review));
     println!();
-    println!(
-        "'{}' is out of the build and still on disk. {} steps remain, and this command ran none \
-         of them:",
-        name.as_str(),
-        steps.len()
-    );
-    for step in steps {
-        println!("  {step}");
-    }
+    print!("{}", super::activation_steps(&destination));
     println!();
     println!(
         "undo this move with `lyracore packages enable {}`.",
@@ -422,20 +395,6 @@ fn recovery_note(name: &PackageName, stamp: Option<&stamp::ProvenanceStamp>) ->
     }
 }
 
-/// The `client sync` line, which says whether there is any client content to sync at all.
-fn client_sync_step(review: &TrustReview) -> String {
-    if review.addons.is_empty() && review.client_overrides == 0 {
-        "lyracore client sync   not needed: this Package ships no client content".to_string()
-    } else {
-        format!(
-            "lyracore client sync   repack the client for its {} addon(s) and {} client \
-             override(s)",
-            review.addons.len(),
-            review.client_overrides
-        )
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
     use super::stamp::ProvenanceStamp;
diff --git a/src/cmd/packages/mod.rs b/src/cmd/packages/mod.rs
index e3e0548..c9b688c 100644
--- a/src/cmd/packages/mod.rs
+++ b/src/cmd/packages/mod.rs
@@ -2,7 +2,7 @@
 //! packages list`, the lifecycle verbs in [`lifecycle`] (`enable`, `disable`, `remove`), the Git
 //! Package Source verbs in [`git`] (the URL form of `add` and all `update` forms), the Official
 //! Package Collection form of `add` in [`official`] (the bare-name form), and the two verbs that
-//! reach a running Realm: [`replay`] (a Package's Delta) and [`config`] (a Package's key-values).
+//! reach a running Realm: [`apply`] (a Package's Delta) and [`config`] (a Package's key-values).
 //!
 //! A Package is a drop-in folder under `packages/<name>/` that the server build compiles into the
 //! module with no core-file edits: `module/build.rs` discovers it, generates `pub mod pkg_<name>`
@@ -25,6 +25,7 @@
 //! operator would meet much later, holding two folders and no way to tell which one the build
 //! compiled.
 
+pub mod apply;
 pub mod artifact;
 pub mod build;
 pub mod check;
@@ -33,7 +34,6 @@ pub mod git;
 pub mod identity;
 pub mod lifecycle;
 pub(crate) mod official;
-pub mod replay;
 pub mod review;
 pub mod script;
 pub mod stamp;
@@ -538,17 +538,8 @@ pub(crate) fn install(
     })?;
 
     println!();
-    println!("'{}' is installed and preflight is green. Two steps remain, and this command runs neither:", name.as_str());
-    println!("  lyracore publish       compile the Package into the module and publish it to every database");
-    if review.addons.is_empty() && review.client_overrides == 0 {
-        println!("  lyracore client sync   not needed: this Package ships no client content");
-    } else {
-        println!(
-            "  lyracore client sync   install its {} addon(s) and {} client override(s) into your client",
-            review.addons.len(),
-            review.client_overrides
-        );
-    }
+    println!("'{}' is installed and preflight is green.", name.as_str());
+    print!("{}", activation_steps(&destination));
     Ok(())
 }
 
@@ -906,26 +897,32 @@ fn validate_scaffold_names(reference: &Path, name: &PackageName) -> Result<()> {
     Ok(())
 }
 
+fn activation_steps(package_dir: &Path) -> String {
+    let mut text = String::new();
+    if ["src", "scripts", "datascripts", "data"]
+        .iter()
+        .any(|dir| package_dir.join(dir).is_dir())
+    {
+        text.push_str("  lyracore packages apply   prepare and activate installed Packages on your development topology\n");
+    }
+    if package_dir.join("client").is_dir() {
+        text.push_str("  lyracore client sync      install enabled client content\n");
+    }
+    text
+}
+
 fn scaffold_next_steps(package_dir: &Path) -> String {
     let mut text = String::new();
     if package_dir.join("scripts").is_dir() || package_dir.join("datascripts").is_dir() {
         text.push_str("Generated artifacts are omitted. Choose distinct Script IDs or Package Spell IDs \
-            before using this copy beside another. Run `lyracore packages build` to build artifacts \
-            for the renamed source, then apply them with `lyracore packages replay` on your development \
-            topology.\n\n");
+            before using this copy beside another. `packages apply` builds the renamed sources.\n\n");
     }
     if package_dir.join("datascripts").is_dir() {
         text.push_str(
-            "The Datascript needs a Base Snapshot from your own client data. Keep its \
-            generated Delta local.\n\n",
+            "The Datascript needs your own client data. Keep its generated Delta local.\n\n",
         );
     }
-    if package_dir.join("src").is_dir() {
-        text.push_str("Publish through the normal realm update to load the Rust half.\n\n");
-    }
-    if package_dir.join("client").is_dir() {
-        text.push_str("Run `lyracore client sync` to install the client half.\n\n");
-    }
+    text.push_str(&activation_steps(package_dir));
     text
 }
 
@@ -1731,7 +1728,7 @@ pub(super) mod tests {
         assert!(!scaffolded.join("src").exists());
         assert!(!scaffolded.join("data/.generated").exists());
         let readme = std::fs::read_to_string(scaffolded.join("README.md")).unwrap();
-        assert!(readme.contains("packages build"));
+        assert!(readme.contains("packages apply"));
         assert!(readme.contains(&format!("/tree/{COLLECTION_REVISION}/example-script")));
         assert!(!readme.contains("packages add"));
 
diff --git a/src/cmd/packages/script.rs b/src/cmd/packages/script.rs
index c72b4f3..2f8331c 100644
--- a/src/cmd/packages/script.rs
+++ b/src/cmd/packages/script.rs
@@ -403,7 +403,7 @@ pub fn packages_with_scripts(project: &ProjectLayout) -> Result<Vec<String>> {
 /// Remove Script Artifacts previously emitted by this build after their last source disappears.
 ///
 /// A `script.identity` sidecar marks the source-built mode. A source-free Script Artifact without
-/// that sidecar is prebuilt Lua and remains untouched, so an Operator can install and replay it
+/// that sidecar is prebuilt Lua and remains untouched, so an Operator can install and apply it
 /// without Bun. Artifact files are removed before the sidecar. If removal fails, the remaining
 /// sidecar keeps any surviving artifact from being mistaken for prebuilt Lua by `packages check`.
 pub fn remove_artifacts_without_sources(project: &ProjectLayout) -> Result<Vec<PathBuf>> {
@@ -888,7 +888,7 @@ pub fn stale(project: &ProjectLayout, artifacts: &[PathBuf]) -> Result<Vec<Strin
         if !has_sources {
             problems.push(format!(
                 "{}: its Runtime Script sources were removed, but a source-built Script Artifact \
-                 remains. Run `lyracore packages build` to remove it before replay.",
+                 remains. Run `lyracore packages build` to remove it before applying.",
                 path.display()
             ));
             continue;
diff --git a/src/cmd/publish.rs b/src/cmd/publish.rs
index 75ebc2a..02221c2 100644
--- a/src/cmd/publish.rs
+++ b/src/cmd/publish.rs
@@ -242,7 +242,7 @@ fn parse_count(database: &str, state: &str, output: &str) -> Result<u64> {
     })
 }
 
-fn require_loot_roll_upgrade_ready(
+pub(crate) fn require_loot_roll_upgrade_ready(
     project: &ProjectLayout,
     runner: &dyn ProcessRunner,
     databases: &[String],
@@ -341,6 +341,26 @@ pub fn run(
     Ok(())
 }
 
+/// Publish one preflighted Shard and repair its schedules before other activation steps.
+/// The caller must gate all targets with preflight and the Loot Roll upgrade check first.
+pub(crate) fn publish_and_repair(
+    project: &ProjectLayout,
+    runner: &dyn ProcessRunner,
+    database: &str,
+) -> Result<()> {
+    runner
+        .run_streaming(&publish_command(project, database)?)
+        .map_err(|error| {
+            Error::Process(format!("Module publish failed at '{database}': {error}"))
+        })?;
+    runner.run_and_wait(&import::call_command(project, database, "debug_repair_after_publish"))
+        .map_err(|error| Error::Process(format!(
+            "'{database}' was published, but schedule repair failed: {error}\n  \
+             Repair it with `spacetime call -s local {database} debug_repair_after_publish` before retrying."
+        )))?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;