diff --git a/CONTEXT.md b/CONTEXT.md
index fde3e17a3..9fa2bea16 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -517,6 +517,18 @@ the effective run speed. Never a second state machine.
 The one shared operation that removes the active Land Mount's aura rows and re-derives the Mount
 Projection. Idempotent, and a no-op for a rider who is not mounted.
 
+### Death and resurrection
+
+**Self-Resurrection Option**:
+The one spell a dead Character may cast on itself from the death dialog. Chosen at death from the
+Character's Soulstone aura, kept through Release Spirit, and spent when the Character is resurrected
+by any path or leaves the world. The client sees it as `PLAYER_SELF_RES_SPELL`.
+_Avoid_: self-res offer, rez offer, resurrect offer (an offer is a resurrect request from another Character)
+
+**Soulstone**:
+The item a Warlock creates, and the Aura its use puts on a Character. A Character that dies while the
+Aura is on it gets a Self-Resurrection Option. The Aura itself does not survive death.
+
 ### Procs
 
 **Proc**:
diff --git a/docs/architecture.md b/docs/architecture.md
index 29409318e..50e6e6da6 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -789,6 +789,7 @@ explains why two rungs of the ladder are written down instead of automated.
 | [`guild-client-check.md`](./guild-client-check.md) | Guilds between two real 5875 clients across a Shard Boundary: founding, invites, chat, ranks, Transfer, emblem, Charter and deletion. Status: outstanding, needs a human. |
 | [`mail-client-check.md`](./mail-client-check.md) | Mail against a real 5875 client. Status: outstanding, needs a human. |
 | [`meeting-stone-client-check.md`](./meeting-stone-client-check.md) | Meeting stones between two real 5875 clients across a Shard Boundary: the JOIN packet, tooltip, minimap button, every status line, Transfer, logout and a stone-formed Party. Status: outstanding, needs a human. |
+| [`self-resurrection-client-check.md`](./self-resurrection-client-check.md) | The Soulstone Self-Resurrection Option against a real 5875 client: the death dialog button, the revived vitals, the buff duration and the Release Spirit edge. Status: outstanding, needs a human. |
 | [`duel-client-check.md`](./duel-client-check.md) | Duel visuals against a real 5875 client, which the automated tests cannot see. Status: outstanding. |
 | [`chat-client-check.md`](./chat-client-check.md) | Realm-wide chat between two real 5875 clients across a Shard Boundary: party, channels and moderation, AFK and DND, whisper, friends, `/who`, ignore, say range, proximity emotes, the language Gate and the flood mute. Status: outstanding, needs a human. |
 | [`raid-client-check.md`](./raid-client-check.md) | Raids, Group Broadcasts, raid chat, member stats across Shards and the Instance Removal countdown against real 5875 clients. Status: outstanding, needs a human. |
diff --git a/docs/self-resurrection-client-check.md b/docs/self-resurrection-client-check.md
new file mode 100644
index 000000000..49ad6a343
--- /dev/null
+++ b/docs/self-resurrection-client-check.md
@@ -0,0 +1,47 @@
+# Self-resurrection client check
+
+Execution status: outstanding. This checklist needs a human with an unmodified 1.12.1 build-5875
+client. The automated tests prove the Self-Resurrection Option at the reducer seam, the
+`PLAYER_SELF_RES_SPELL` bytes, and the `CMSG_SELF_RES` dispatch. They cannot prove what the client
+draws or when it sends the opcode. The field index and the 30 minute duration come from emulator
+source and the ClassicDB dump, not from a client.
+
+Use only an isolated non-production LyraCore stack. Never point these steps at a production database,
+and never use `spacetime publish -c`. Point the client's realmlist at the isolated stack first. Import
+the operator-owned 1.12.1 client data with spells and items, so the five Soulstone Resurrection
+ranks, their self-resurrect spells and the Soulstone item templates exist. Run the Gateway at debug
+log level.
+
+Prepare one Warlock of level 18 or higher, and one Priest who knows Resurrection for the ally step.
+
+Data, before any client:
+
+- [ ] On the isolated stack, read `game_spell` and `game_spell_effect` for spells 20707 and 3026 with
+      `spacetime sql`. For 20707 confirm `duration_ms = 1800000`, `cast_time_ms = 3000`, and one
+      effect with kind `0xB5` (`A_SELF_RESURRECT`), `p0 = 3026`, `p0_kind = 15`. For 3026 confirm
+      one effect with kind `0x26` (`E_SELF_RESURRECT`), `base_points = -400`, `p0 = 700`. Record any
+      difference.
+
+Soulstone:
+
+- [ ] Grant the Warlock a Minor Soulstone (`debug_grant_item <guid> 5232 1`) and use it on itself.
+      Record whether the 3 second cast bar shows, and whether the buff shows a 30 minute timer.
+- [ ] Kill the Warlock (`debug_set_health <guid> 0`). Confirm the death dialog shows a second button
+      beside Release Spirit. Record its exact text.
+- [ ] Click it. Confirm the death screen closes, health shows 400, mana shows 700 (or the Warlock's
+      max mana if lower), no Resurrection Sickness, and no corpse. Record the numbers.
+- [ ] Record whether the client plays any cast animation or sound on use. The server sends no cast
+      packet for it.
+- [ ] Repeat, but click Release Spirit first. Record whether the ghost sees any self-resurrection
+      prompt or button. The server keeps the option for the ghost; if the client offers a way to use
+      it, confirm it works.
+- [ ] Repeat, but die inside the Deadmines and release into Westfall. Record whether the option is
+      still offered. The server does not carry it across a Shard hop.
+- [ ] Die with a Soulstone, let the Priest resurrect the Warlock, and accept. Then die without a
+      Soulstone. Confirm the dialog shows only Release Spirit.
+- [ ] Die with a Soulstone, log out on the death screen, and log back in. Record the state.
+- [ ] Use a Soulstone, then move during the 3 second cast. Record whether the item is lost. Every
+      timed consumable is consumed when its cast starts.
+
+Record the server commit, the client build on the login screen, Character names and levels, each
+dialog text, each number read from the client, and any disconnect or error dialog.
diff --git a/gateway/src/codec/tests.rs b/gateway/src/codec/tests.rs
index db96ae6cb..cb3841e7e 100644
--- a/gateway/src/codec/tests.rs
+++ b/gateway/src/codec/tests.rs
@@ -2615,6 +2615,33 @@ fn player_ammo_id_values_is_player_only_no_object_type() {
     );
 }
 
+#[test]
+fn self_res_spell_values_sets_only_field_1224() {
+    // PLAYER_SELF_RES_SPELL is vanilla update field 1224 (cmangos-classic UpdateFields.h:
+    // PLAYER_AMMO_ID + 1). 1224 = 38 * 32 + 8, so the mask spans 39 blocks: 38 empty ones (block 0
+    // carries no OBJECT_FIELD_TYPE bit 2), then bit 8 of block 38, then the one value word. Minor
+    // Soulstone's self-resurrect spell is 3026 = 0x0BD2.
+    let msg = build_self_res_spell_values(1, 3026);
+    let mut buf = Vec::new();
+    msg.write_unencrypted_server(&mut buf).unwrap();
+    let mut tail = vec![39u8];
+    tail.extend(std::iter::repeat_n(0u8, 38 * 4));
+    tail.extend([0x00, 0x01, 0x00, 0x00]);
+    tail.extend([0xD2, 0x0B, 0x00, 0x00]);
+    assert!(
+        buf.ends_with(&tail),
+        "the VALUES mask must carry field 1224 alone; tail was {:02x?}",
+        &buf[buf.len().saturating_sub(tail.len())..]
+    );
+
+    let cleared = build_self_res_spell_values(1, 0);
+    let mut buf = Vec::new();
+    cleared.write_unencrypted_server(&mut buf).unwrap();
+    tail.truncate(tail.len() - 4);
+    tail.extend([0x00; 4]);
+    assert!(buf.ends_with(&tail), "spell 0 clears the field");
+}
+
 #[test]
 fn player_xp_values_carries_xp_and_next_level_no_object_type() {
     let msg = build_player_xp_values(1, 450, 1000);
diff --git a/gateway/src/codec/values.rs b/gateway/src/codec/values.rs
index 9d36683ff..cce381c0a 100644
--- a/gateway/src/codec/values.rs
+++ b/gateway/src/codec/values.rs
@@ -436,6 +436,15 @@ pub fn build_player_ammo_id_values(guid: u64, ammo_entry: u32) -> SMSG_UPDATE_OB
     })
 }
 
+/// Build a VALUES partial-update carrying `PLAYER_SELF_RES_SPELL`, the Self-Resurrection Option the
+/// 5875 death dialog offers as its second button. `spell_id` 0 clears it. Owner-only field; same
+/// `dirty_reset` discipline as `build_coinage_values`, so `OBJECT_FIELD_TYPE` is never re-sent.
+pub fn build_self_res_spell_values(guid: u64, spell_id: u32) -> SMSG_UPDATE_OBJECT {
+    player_values(guid, |player| {
+        player.set_player_self_res_spell(spell_id as i32);
+    })
+}
+
 /// `PLAYER_CHARACTER_POINTS1` partial VALUES — the talent pane's unspent-points counter. Pushed
 /// LIVE after a talent pick (fires the client's CHARACTER_POINTS_CHANGED → TalentFrame refresh)
 /// and once after the login CREATE for a character with spent points (the CREATE's formula counts
diff --git a/gateway/src/stdb/bindings/debug_self_resurrect_reducer.rs b/gateway/src/stdb/bindings/debug_self_resurrect_reducer.rs
new file mode 100644
index 000000000..b36eac189
--- /dev/null
+++ b/gateway/src/stdb/bindings/debug_self_resurrect_reducer.rs
@@ -0,0 +1,68 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct DebugSelfResurrectArgs {
+    pub character_guid: u64,
+}
+
+impl From<DebugSelfResurrectArgs> for super::Reducer {
+    fn from(args: DebugSelfResurrectArgs) -> Self {
+        Self::DebugSelfResurrect {
+            character_guid: args.character_guid,
+        }
+    }
+}
+
+impl __sdk::InModule for DebugSelfResurrectArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the reducer `debug_self_resurrect`.
+///
+/// Implemented for [`super::RemoteReducers`].
+pub trait debug_self_resurrect {
+    /// Request that the remote module invoke the reducer `debug_self_resurrect` to run as soon as possible.
+    ///
+    /// This method returns immediately, and errors only if we are unable to send the request.
+    /// The reducer will run asynchronously in the future,
+    ///  and this method provides no way to listen for its completion status.
+    /// /// Use [`debug_self_resurrect:debug_self_resurrect_then`] to run a callback after the reducer completes.
+    fn debug_self_resurrect(&self, character_guid: u64) -> __sdk::Result<()> {
+        self.debug_self_resurrect_then(character_guid, |_, _| {})
+    }
+
+    /// Request that the remote module invoke the reducer `debug_self_resurrect` to run as soon as possible,
+    /// registering `callback` to run when we are notified that the reducer completed.
+    ///
+    /// This method returns immediately, and errors only if we are unable to send the request.
+    /// The reducer will run asynchronously in the future,
+    ///  and its status can be observed with the `callback`.
+    fn debug_self_resurrect_then(
+        &self,
+        character_guid: u64,
+
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl debug_self_resurrect for super::RemoteReducers {
+    fn debug_self_resurrect_then(
+        &self,
+        character_guid: u64,
+
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(DebugSelfResurrectArgs { character_guid }, callback)
+    }
+}
diff --git a/gateway/src/stdb/bindings/game_self_resurrect_option_table.rs b/gateway/src/stdb/bindings/game_self_resurrect_option_table.rs
new file mode 100644
index 000000000..55aca3cee
--- /dev/null
+++ b/gateway/src/stdb/bindings/game_self_resurrect_option_table.rs
@@ -0,0 +1,231 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use super::self_resurrect_option_type::SelfResurrectOption;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_self_resurrect_option`.
+///
+/// Obtain a handle from the [`GameSelfResurrectOptionTableAccess::game_self_resurrect_option`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_self_resurrect_option()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_self_resurrect_option().on_insert(...)`.
+pub struct GameSelfResurrectOptionTableHandle<'ctx> {
+    imp: __sdk::TableHandle<SelfResurrectOption>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_self_resurrect_option`.
+pub struct GameSelfResurrectOptionTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameSelfResurrectOptionTableAccessor {
+    type Row = SelfResurrectOption;
+    type Handle<'db> = GameSelfResurrectOptionTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_self_resurrect_option()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_self_resurrect_option`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameSelfResurrectOptionTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameSelfResurrectOptionTableHandle`], which mediates access to the table `game_self_resurrect_option`.
+    fn game_self_resurrect_option(&self) -> GameSelfResurrectOptionTableHandle<'_>;
+}
+
+impl GameSelfResurrectOptionTableAccess for super::RemoteTables {
+    fn game_self_resurrect_option(&self) -> GameSelfResurrectOptionTableHandle<'_> {
+        GameSelfResurrectOptionTableHandle {
+            imp: self
+                .imp
+                .get_table::<SelfResurrectOption>("game_self_resurrect_option"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameSelfResurrectOptionInsertCallbackId(__sdk::CallbackId);
+pub struct GameSelfResurrectOptionDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameSelfResurrectOptionTableHandle<'ctx> {
+    type Row = SelfResurrectOption;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = SelfResurrectOption> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameSelfResurrectOptionTableHandle<'ctx> {
+    type Row = SelfResurrectOption;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = SelfResurrectOption> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameSelfResurrectOptionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionInsertCallbackId {
+        GameSelfResurrectOptionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameSelfResurrectOptionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameSelfResurrectOptionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionDeleteCallbackId {
+        GameSelfResurrectOptionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameSelfResurrectOptionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameSelfResurrectOptionTableHandle<'ctx> {
+    type InsertCallbackId = GameSelfResurrectOptionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionInsertCallbackId {
+        GameSelfResurrectOptionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameSelfResurrectOptionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameSelfResurrectOptionTableHandle<'ctx> {
+    type DeleteCallbackId = GameSelfResurrectOptionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionDeleteCallbackId {
+        GameSelfResurrectOptionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameSelfResurrectOptionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameSelfResurrectOptionUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameSelfResurrectOptionTableHandle<'ctx> {
+    type UpdateCallbackId = GameSelfResurrectOptionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionUpdateCallbackId {
+        GameSelfResurrectOptionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameSelfResurrectOptionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameSelfResurrectOptionTableHandle<'ctx> {
+    type UpdateCallbackId = GameSelfResurrectOptionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameSelfResurrectOptionUpdateCallbackId {
+        GameSelfResurrectOptionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameSelfResurrectOptionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `character_guid` unique index on the table `game_self_resurrect_option`,
+/// which allows point queries on the field of the same name
+/// via the [`GameSelfResurrectOptionCharacterGuidUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_self_resurrect_option().character_guid().find(...)`.
+pub struct GameSelfResurrectOptionCharacterGuidUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<SelfResurrectOption, u64>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameSelfResurrectOptionTableHandle<'ctx> {
+    /// Get a handle on the `character_guid` unique index on the table `game_self_resurrect_option`.
+    pub fn character_guid(&self) -> GameSelfResurrectOptionCharacterGuidUnique<'ctx> {
+        GameSelfResurrectOptionCharacterGuidUnique {
+            imp: self.imp.get_unique_constraint::<u64>("character_guid"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameSelfResurrectOptionCharacterGuidUnique<'ctx> {
+    /// Find the subscribed row whose `character_guid` column value is equal to `col_val`,
+    /// if such a row is present in the client cache.
+    pub fn find(&self, col_val: &u64) -> Option<SelfResurrectOption> {
+        self.imp.find(col_val)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table =
+        client_cache.get_or_make_table::<SelfResurrectOption>("game_self_resurrect_option");
+    _table.add_unique_constraint::<u64>("character_guid", |row| &row.character_guid);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<SelfResurrectOption>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<SelfResurrectOption>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `SelfResurrectOption`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_self_resurrect_optionQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `SelfResurrectOption`.
+    fn game_self_resurrect_option(&self) -> __sdk::__query_builder::Table<SelfResurrectOption>;
+}
+
+impl game_self_resurrect_optionQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_self_resurrect_option(&self) -> __sdk::__query_builder::Table<SelfResurrectOption> {
+        __sdk::__query_builder::Table::new("game_self_resurrect_option")
+    }
+}
diff --git a/gateway/src/stdb/bindings/gw_self_resurrect_reducer.rs b/gateway/src/stdb/bindings/gw_self_resurrect_reducer.rs
new file mode 100644
index 000000000..2bb0c79c8
--- /dev/null
+++ b/gateway/src/stdb/bindings/gw_self_resurrect_reducer.rs
@@ -0,0 +1,70 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::session_actor_type::SessionActor;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct GwSelfResurrectArgs {
+    pub request_actor: SessionActor,
+}
+
+impl From<GwSelfResurrectArgs> for super::Reducer {
+    fn from(args: GwSelfResurrectArgs) -> Self {
+        Self::GwSelfResurrect {
+            request_actor: args.request_actor,
+        }
+    }
+}
+
+impl __sdk::InModule for GwSelfResurrectArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the reducer `gw_self_resurrect`.
+///
+/// Implemented for [`super::RemoteReducers`].
+pub trait gw_self_resurrect {
+    /// Request that the remote module invoke the reducer `gw_self_resurrect` to run as soon as possible.
+    ///
+    /// This method returns immediately, and errors only if we are unable to send the request.
+    /// The reducer will run asynchronously in the future,
+    ///  and this method provides no way to listen for its completion status.
+    /// /// Use [`gw_self_resurrect:gw_self_resurrect_then`] to run a callback after the reducer completes.
+    fn gw_self_resurrect(&self, request_actor: SessionActor) -> __sdk::Result<()> {
+        self.gw_self_resurrect_then(request_actor, |_, _| {})
+    }
+
+    /// Request that the remote module invoke the reducer `gw_self_resurrect` to run as soon as possible,
+    /// registering `callback` to run when we are notified that the reducer completed.
+    ///
+    /// This method returns immediately, and errors only if we are unable to send the request.
+    /// The reducer will run asynchronously in the future,
+    ///  and its status can be observed with the `callback`.
+    fn gw_self_resurrect_then(
+        &self,
+        request_actor: SessionActor,
+
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl gw_self_resurrect for super::RemoteReducers {
+    fn gw_self_resurrect_then(
+        &self,
+        request_actor: SessionActor,
+
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(GwSelfResurrectArgs { request_actor }, callback)
+    }
+}
diff --git a/gateway/src/stdb/bindings/mod.rs b/gateway/src/stdb/bindings/mod.rs
index 1ba2aa7ee..e82bf4457 100644
--- a/gateway/src/stdb/bindings/mod.rs
+++ b/gateway/src/stdb/bindings/mod.rs
@@ -249,6 +249,7 @@ pub mod debug_seed_creature_ai_fixtures_reducer;
 pub mod debug_seed_mail_reducer;
 pub mod debug_seed_package_config_reducer;
 pub mod debug_seed_scenario_fixtures_reducer;
+pub mod debug_self_resurrect_reducer;
 pub mod debug_sell_item_reducer;
 pub mod debug_set_health_reducer;
 pub mod debug_set_lethal_damage_floor_fixture_reducer;
@@ -612,6 +613,7 @@ pub mod game_resurrect_request_table;
 pub mod game_roll_event_table;
 pub mod game_school_lockout_table;
 pub mod game_script_table;
+pub mod game_self_resurrect_option_table;
 pub mod game_session_reaper_schedule_table;
 pub mod game_session_table;
 pub mod game_sessionless_action_consent_table;
@@ -806,6 +808,7 @@ pub mod gw_repair_item_reducer;
 pub mod gw_repop_reducer;
 pub mod gw_reset_talents_reducer;
 pub mod gw_respond_resurrect_reducer;
+pub mod gw_self_resurrect_reducer;
 pub mod gw_sell_item_reducer;
 pub mod gw_send_chat_reducer;
 pub mod gw_send_emote_reducer;
@@ -1070,6 +1073,7 @@ pub mod scale_selected_threat_instruction_type;
 pub mod school_lockout_type;
 pub mod script_type;
 pub mod seeker_facts_type;
+pub mod self_resurrect_option_type;
 pub mod server_config_type;
 pub mod session_actor_type;
 pub mod session_reaper_schedule_type;
@@ -1415,6 +1419,7 @@ pub use debug_seed_creature_ai_fixtures_reducer::debug_seed_creature_ai_fixtures
 pub use debug_seed_mail_reducer::debug_seed_mail;
 pub use debug_seed_package_config_reducer::debug_seed_package_config;
 pub use debug_seed_scenario_fixtures_reducer::debug_seed_scenario_fixtures;
+pub use debug_self_resurrect_reducer::debug_self_resurrect;
 pub use debug_sell_item_reducer::debug_sell_item;
 pub use debug_set_health_reducer::debug_set_health;
 pub use debug_set_lethal_damage_floor_fixture_reducer::debug_set_lethal_damage_floor_fixture;
@@ -1778,6 +1783,7 @@ pub use game_resurrect_request_table::*;
 pub use game_roll_event_table::*;
 pub use game_school_lockout_table::*;
 pub use game_script_table::*;
+pub use game_self_resurrect_option_table::*;
 pub use game_session_reaper_schedule_table::*;
 pub use game_session_table::*;
 pub use game_sessionless_action_consent_table::*;
@@ -1972,6 +1978,7 @@ pub use gw_repair_item_reducer::gw_repair_item;
 pub use gw_repop_reducer::gw_repop;
 pub use gw_reset_talents_reducer::gw_reset_talents;
 pub use gw_respond_resurrect_reducer::gw_respond_resurrect;
+pub use gw_self_resurrect_reducer::gw_self_resurrect;
 pub use gw_sell_item_reducer::gw_sell_item;
 pub use gw_send_chat_reducer::gw_send_chat;
 pub use gw_send_emote_reducer::gw_send_emote;
@@ -2236,6 +2243,7 @@ pub use scale_selected_threat_instruction_type::ScaleSelectedThreatInstruction;
 pub use school_lockout_type::SchoolLockout;
 pub use script_type::Script;
 pub use seeker_facts_type::SeekerFacts;
+pub use self_resurrect_option_type::SelfResurrectOption;
 pub use server_config_type::ServerConfig;
 pub use session_actor_type::SessionActor;
 pub use session_reaper_schedule_type::SessionReaperSchedule;
@@ -2973,6 +2981,9 @@ pub enum Reducer {
         value: String,
     },
     DebugSeedScenarioFixtures,
+    DebugSelfResurrect {
+        character_guid: u64,
+    },
     DebugSellItem {
         character_guid: u64,
         vendor_guid: u64,
@@ -3729,6 +3740,9 @@ pub enum Reducer {
         request_actor: SessionActor,
         accept: bool,
     },
+    GwSelfResurrect {
+        request_actor: SessionActor,
+    },
     GwSellItem {
         request_actor: SessionActor,
         vendor_guid: u64,
@@ -4523,6 +4537,7 @@ impl __sdk::Reducer for Reducer {
             Reducer::DebugSeedMail { .. } => "debug_seed_mail",
             Reducer::DebugSeedPackageConfig { .. } => "debug_seed_package_config",
             Reducer::DebugSeedScenarioFixtures => "debug_seed_scenario_fixtures",
+            Reducer::DebugSelfResurrect { .. } => "debug_self_resurrect",
             Reducer::DebugSellItem { .. } => "debug_sell_item",
             Reducer::DebugSetHealth { .. } => "debug_set_health",
             Reducer::DebugSetLethalDamageFloorFixture { .. } => {
@@ -4729,6 +4744,7 @@ impl __sdk::Reducer for Reducer {
             Reducer::GwRepop { .. } => "gw_repop",
             Reducer::GwResetTalents { .. } => "gw_reset_talents",
             Reducer::GwRespondResurrect { .. } => "gw_respond_resurrect",
+            Reducer::GwSelfResurrect { .. } => "gw_self_resurrect",
             Reducer::GwSellItem { .. } => "gw_sell_item",
             Reducer::GwSendChat { .. } => "gw_send_chat",
             Reducer::GwSendEmote { .. } => "gw_send_emote",
@@ -6001,7 +6017,12 @@ Reducer::DebugSeedMail{
 }),
             Reducer::DebugSeedScenarioFixtures => __sats::bsatn::to_vec(&debug_seed_scenario_fixtures_reducer::DebugSeedScenarioFixturesArgs {
                 }),
-Reducer::DebugSellItem{
+Reducer::DebugSelfResurrect{
+                character_guid,
+}             => __sats::bsatn::to_vec(&debug_self_resurrect_reducer::DebugSelfResurrectArgs {
+                character_guid: character_guid.clone(),
+}),
+            Reducer::DebugSellItem{
                 character_guid,
                 vendor_guid,
                 slot,
@@ -7360,6 +7381,11 @@ Reducer::GwIgnoreTrade{
 }             => __sats::bsatn::to_vec(&gw_respond_resurrect_reducer::GwRespondResurrectArgs {
                 request_actor: request_actor.clone(),
                 accept: accept.clone(),
+}),
+            Reducer::GwSelfResurrect{
+                request_actor,
+}             => __sats::bsatn::to_vec(&gw_self_resurrect_reducer::GwSelfResurrectArgs {
+                request_actor: request_actor.clone(),
 }),
             Reducer::GwSellItem{
                 request_actor,
@@ -8727,6 +8753,7 @@ pub struct DbUpdate {
     game_roll_event: __sdk::TableUpdate<RollEvent>,
     game_school_lockout: __sdk::TableUpdate<SchoolLockout>,
     game_script: __sdk::TableUpdate<Script>,
+    game_self_resurrect_option: __sdk::TableUpdate<SelfResurrectOption>,
     game_session: __sdk::TableUpdate<Session>,
     game_session_reaper_schedule: __sdk::TableUpdate<SessionReaperSchedule>,
     game_sessionless_action_consent: __sdk::TableUpdate<SessionlessActionConsent>,
@@ -9536,6 +9563,9 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
                 "game_script" => db_update
                     .game_script
                     .append(game_script_table::parse_table_update(table_update)?),
+                "game_self_resurrect_option" => db_update.game_self_resurrect_option.append(
+                    game_self_resurrect_option_table::parse_table_update(table_update)?,
+                ),
                 "game_session" => db_update
                     .game_session
                     .append(game_session_table::parse_table_update(table_update)?),
@@ -10784,6 +10814,12 @@ impl __sdk::DbUpdate for DbUpdate {
         diff.game_script = cache
             .apply_diff_to_table::<Script>("game_script", &self.game_script)
             .with_updates_by_pk(|row| &row.script_id);
+        diff.game_self_resurrect_option = cache
+            .apply_diff_to_table::<SelfResurrectOption>(
+                "game_self_resurrect_option",
+                &self.game_self_resurrect_option,
+            )
+            .with_updates_by_pk(|row| &row.character_guid);
         diff.game_session = cache
             .apply_diff_to_table::<Session>("game_session", &self.game_session)
             .with_updates_by_pk(|row| &row.account_id);
@@ -11712,6 +11748,9 @@ impl __sdk::DbUpdate for DbUpdate {
                 "game_script" => db_update
                     .game_script
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "game_self_resurrect_option" => db_update
+                    .game_self_resurrect_option
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "game_session" => db_update
                     .game_session
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
@@ -12580,6 +12619,9 @@ impl __sdk::DbUpdate for DbUpdate {
                 "game_script" => db_update
                     .game_script
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "game_self_resurrect_option" => db_update
+                    .game_self_resurrect_option
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "game_session" => db_update
                     .game_session
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
@@ -13001,6 +13043,7 @@ pub struct AppliedDiff<'r> {
     game_roll_event: __sdk::TableAppliedDiff<'r, RollEvent>,
     game_school_lockout: __sdk::TableAppliedDiff<'r, SchoolLockout>,
     game_script: __sdk::TableAppliedDiff<'r, Script>,
+    game_self_resurrect_option: __sdk::TableAppliedDiff<'r, SelfResurrectOption>,
     game_session: __sdk::TableAppliedDiff<'r, Session>,
     game_session_reaper_schedule: __sdk::TableAppliedDiff<'r, SessionReaperSchedule>,
     game_sessionless_action_consent: __sdk::TableAppliedDiff<'r, SessionlessActionConsent>,
@@ -14151,6 +14194,11 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
             event,
         );
         callbacks.invoke_table_row_callbacks::<Script>("game_script", &self.game_script, event);
+        callbacks.invoke_table_row_callbacks::<SelfResurrectOption>(
+            "game_self_resurrect_option",
+            &self.game_self_resurrect_option,
+            event,
+        );
         callbacks.invoke_table_row_callbacks::<Session>("game_session", &self.game_session, event);
         callbacks.invoke_table_row_callbacks::<SessionReaperSchedule>(
             "game_session_reaper_schedule",
@@ -15320,6 +15368,7 @@ impl __sdk::SpacetimeModule for RemoteModule {
         game_roll_event_table::register_table(client_cache);
         game_school_lockout_table::register_table(client_cache);
         game_script_table::register_table(client_cache);
+        game_self_resurrect_option_table::register_table(client_cache);
         game_session_table::register_table(client_cache);
         game_session_reaper_schedule_table::register_table(client_cache);
         game_sessionless_action_consent_table::register_table(client_cache);
@@ -15607,6 +15656,7 @@ impl __sdk::SpacetimeModule for RemoteModule {
         "game_roll_event",
         "game_school_lockout",
         "game_script",
+        "game_self_resurrect_option",
         "game_session",
         "game_session_reaper_schedule",
         "game_sessionless_action_consent",
diff --git a/gateway/src/stdb/bindings/self_resurrect_option_type.rs b/gateway/src/stdb/bindings/self_resurrect_option_type.rs
new file mode 100644
index 000000000..14d2a7d57
--- /dev/null
+++ b/gateway/src/stdb/bindings/self_resurrect_option_type.rs
@@ -0,0 +1,52 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct SelfResurrectOption {
+    pub character_guid: u64,
+    pub spell_id: u32,
+}
+
+impl __sdk::InModule for SelfResurrectOption {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `SelfResurrectOption`.
+///
+/// Provides typed access to columns for query building.
+pub struct SelfResurrectOptionCols {
+    pub character_guid: __sdk::__query_builder::Col<SelfResurrectOption, u64>,
+    pub spell_id: __sdk::__query_builder::Col<SelfResurrectOption, u32>,
+}
+
+impl __sdk::__query_builder::HasCols for SelfResurrectOption {
+    type Cols = SelfResurrectOptionCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        SelfResurrectOptionCols {
+            character_guid: __sdk::__query_builder::Col::new(table_name, "character_guid"),
+            spell_id: __sdk::__query_builder::Col::new(table_name, "spell_id"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `SelfResurrectOption`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct SelfResurrectOptionIxCols {
+    pub character_guid: __sdk::__query_builder::IxCol<SelfResurrectOption, u64>,
+}
+
+impl __sdk::__query_builder::HasIxCols for SelfResurrectOption {
+    type IxCols = SelfResurrectOptionIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        SelfResurrectOptionIxCols {
+            character_guid: __sdk::__query_builder::IxCol::new(table_name, "character_guid"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for SelfResurrectOption {}
diff --git a/gateway/src/stdb/connection.rs b/gateway/src/stdb/connection.rs
index 0d8473b87..67507e4de 100644
--- a/gateway/src/stdb/connection.rs
+++ b/gateway/src/stdb/connection.rs
@@ -1192,6 +1192,7 @@ fn coordinator_queries(sharded_tables: bool) -> Vec<&'static str> {
         // single-database gateway's shared path works too; on realm-core the same subscription
         // additionally feeds the per-session cross-shard twins, unchanged.
         "SELECT * FROM game_resurrect_request",
+        "SELECT * FROM game_self_resurrect_option",
         "SELECT * FROM game_system_message_event",
         "SELECT * FROM game_mail_arrival",
         "SELECT * FROM game_group_event",
diff --git a/gateway/src/stdb/reducers.rs b/gateway/src/stdb/reducers.rs
index 0cc9b87da..eecb72122 100644
--- a/gateway/src/stdb/reducers.rs
+++ b/gateway/src/stdb/reducers.rs
@@ -3134,6 +3134,20 @@ impl Coordinator {
         )
     }
 
+    /// Use the caller's Self-Resurrection Option (`CMSG_SELF_RES`) over the coordinator connection.
+    /// Rides the coordinator connection as `gw_self_resurrect`.
+    pub fn self_resurrect(&self, _account_id: u64, actor_guid: u64) -> Result<()> {
+        if actor_guid == 0 {
+            return Err(anyhow!("self_resurrect: actor_guid unresolved"));
+        }
+        let coord = self.0.call_pipe();
+        call_reducer!(
+            coord.conn.reducers,
+            "gw_self_resurrect",
+            gw_self_resurrect_then(self.session_actor(actor_guid))
+        )
+    }
+
     /// Spirit-Healer resurrect (`CMSG_SPIRIT_HEALER_ACTIVATE`) over the coordinator connection: the
     /// module res's the caller in place at 50% + applies Resurrection Sickness if it's a ghost.
     /// `gw_spirit_res` takes no `healer_guid`.
diff --git a/gateway/src/stdb/subscriptions.rs b/gateway/src/stdb/subscriptions.rs
index 2e81fbf0e..30972e43d 100644
--- a/gateway/src/stdb/subscriptions.rs
+++ b/gateway/src/stdb/subscriptions.rs
@@ -2655,6 +2655,15 @@ pub(crate) fn resurrect_request_outbound(row: &ResurrectRequest) -> Vec<Outbound
     ))]
 }
 
+/// Self-Resurrection Option: the owner's `PLAYER_SELF_RES_SPELL` write. `spell_id` 0 clears it.
+/// Audience: the option's Character, resolved by the caller.
+pub(crate) fn self_res_option_outbound(character_guid: u64, spell_id: u32) -> Vec<Outbound> {
+    let m = codec::build_self_res_spell_values(character_guid, spell_id);
+    vec![Outbound::One(ServerOpcodeMessage::SMSG_UPDATE_OBJECT(
+        Box::new(m),
+    ))]
+}
+
 /// Projectile impact: the floating damage number for a projectile that
 /// finished its travel — never a START/GO. Pure over the row; broadcast.
 pub(crate) fn impact_event_outbound(row: &SpellImpactEvent) -> Vec<Outbound> {
diff --git a/gateway/src/stdb/world_store.rs b/gateway/src/stdb/world_store.rs
index 2047c1b12..f588cd274 100644
--- a/gateway/src/stdb/world_store.rs
+++ b/gateway/src/stdb/world_store.rs
@@ -1040,6 +1040,10 @@ impl WorldStore for Coordinator {
         self.resurrect_response(account_id, self_guid, accept)
     }
 
+    fn self_resurrect(&self, account_id: u64, self_guid: u64) -> Result<()> {
+        self.self_resurrect(account_id, self_guid)
+    }
+
     fn spirit_healer_res(&self, account_id: u64, self_guid: u64, healer_guid: u64) -> Result<()> {
         self.spirit_healer_res(account_id, self_guid, healer_guid)
     }
diff --git a/gateway/src/stdb/world_view.rs b/gateway/src/stdb/world_view.rs
index 924ff7d6b..96a9d65fc 100644
--- a/gateway/src/stdb/world_view.rs
+++ b/gateway/src/stdb/world_view.rs
@@ -1015,6 +1015,25 @@ fn register_shard_callbacks(
         &view,
         move |v, row| resurrect_offered(v, shard, row),
     );
+    // The Self-Resurrection Option is state, not an event: a replayed row re-sends the same field.
+    wire_insert(
+        db.game_self_resurrect_option(),
+        "game_self_resurrect_option.insert",
+        &view,
+        move |v, row| self_res_option_changed(v, shard, row.character_guid, row.spell_id),
+    );
+    wire_update(
+        db.game_self_resurrect_option(),
+        "game_self_resurrect_option.update",
+        &view,
+        move |v, _old, row| self_res_option_changed(v, shard, row.character_guid, row.spell_id),
+    );
+    wire_delete(
+        db.game_self_resurrect_option(),
+        "game_self_resurrect_option.delete",
+        &view,
+        move |v, row| self_res_option_changed(v, shard, row.character_guid, 0),
+    );
     // Guild rows exist only on Realm-core. On a sharded realm this Shard holds none, and
     // `arm_realm_private` relays them from the Realm-core connection instead.
     wire_guild_relays(
@@ -2415,6 +2434,20 @@ fn resurrect_offered(view: &WorldView, shard: ShardId, row: &ResurrectRequest) {
     });
 }
 
+/// A Self-Resurrection Option changed → the owner's `PLAYER_SELF_RES_SPELL` (0 clears it), and
+/// nobody else's.
+fn self_res_option_changed(view: &WorldView, shard: ShardId, character_guid: u64, spell_id: u32) {
+    let Some(viewer) = view.viewer_of_owner_on_shard(shard, OwnerGuid(character_guid)) else {
+        return;
+    };
+    if !super::subscriptions::private_recipient_audience(character_guid, viewer.self_guid) {
+        return;
+    }
+    enqueue(viewer.clone(), move |_| {
+        super::subscriptions::self_res_option_outbound(character_guid, spell_id)
+    });
+}
+
 /// A Realm Chat Line landed → one `SMSG_MESSAGECHAT` per recipient with a World Session on this
 /// Gateway, whatever Shard it plays on. The Module chose the audience. The only per-listener
 /// filter here is the listener's own ignore list, and only for lines the Module marked ignorable.
@@ -3351,10 +3384,10 @@ mod family_audience_tests {
         exploration_outbound_for_word, guild_event_appeared, guild_membership_changed,
         instance_removal_ended, instance_removal_started, instance_removal_time_left_ms,
         is_initial_apply, item_owner_job, levelup_appeared, mail_arrived, petition_event_appeared,
-        reputation_appeared, resident_countdown_ms, sweep_into_view, system_message_appeared,
-        teleport_appeared, weather_changed, xp_appeared, zone_crossed, BoundIdentity,
-        ExplorationReplay, GuildMembershipRead, GuildRosterSnapshotRead, MotionPending, OwnerGuid,
-        PetitionRead, Viewer, WorldView,
+        reputation_appeared, resident_countdown_ms, self_res_option_changed, sweep_into_view,
+        system_message_appeared, teleport_appeared, weather_changed, xp_appeared, zone_crossed,
+        BoundIdentity, ExplorationReplay, GuildMembershipRead, GuildRosterSnapshotRead,
+        MotionPending, OwnerGuid, PetitionRead, Viewer, WorldView,
     };
     use crate::stdb::aoi::ViewerGates;
     use crate::stdb::bindings::{
@@ -4464,6 +4497,55 @@ mod family_audience_tests {
         assert!(removed_rx.try_recv().is_err());
     }
 
+    /// The owner's `PLAYER_SELF_RES_SPELL` from one queued VALUES packet.
+    fn self_res_spell_of(outbound: Vec<Outbound>) -> Option<i32> {
+        use wow_world_messages::vanilla::{Object, UpdateMask};
+        let [Outbound::One(ServerOpcodeMessage::SMSG_UPDATE_OBJECT(packet))] = outbound.as_slice()
+        else {
+            panic!("the owner must receive one SMSG_UPDATE_OBJECT");
+        };
+        match packet.objects.as_slice() {
+            [Object::Values {
+                mask1: UpdateMask::Player(player),
+                ..
+            }] => player.player_self_res_spell(),
+            other => panic!("expected one Player VALUES block, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn a_self_resurrect_option_reaches_only_its_character_on_this_shard() {
+        let view = WorldView::new(true);
+        let anchor = CellKey::at(0, 0, 0, 0);
+        let (owner_tx, owner_rx) = SessionTx::with_depth(0);
+        let (bystander_tx, bystander_rx) = SessionTx::with_depth(0);
+        let (remote_tx, remote_rx) = SessionTx::with_depth(0);
+        view.add_viewer_on_shard(viewer_with_tx(1, 9001, identity(1), owner_tx), anchor, 0);
+        view.add_viewer_on_shard(
+            viewer_with_tx(2, 9002, identity(2), bystander_tx),
+            anchor,
+            0,
+        );
+        view.add_viewer_on_shard(viewer_with_tx(3, 9003, identity(3), remote_tx), anchor, 1);
+
+        self_res_option_changed(&view, 0, 9001, 3026);
+        assert_eq!(self_res_spell_of(queued_job(&owner_rx)), Some(3026));
+        assert!(owner_rx.try_recv().is_err(), "one change queues one job");
+        assert!(
+            bystander_rx.try_recv().is_err(),
+            "a nearby Character never sees another Character's option"
+        );
+
+        self_res_option_changed(&view, 0, 9003, 3026);
+        assert!(
+            remote_rx.try_recv().is_err(),
+            "a Character on another Shard is not this Shard's to address"
+        );
+
+        self_res_option_changed(&view, 0, 9001, 0);
+        assert_eq!(self_res_spell_of(queued_job(&owner_rx)), Some(0));
+    }
+
     #[test]
     fn a_mail_arrival_reaches_its_recipient_on_any_shard_and_an_unknown_guid_gets_nothing() {
         let view = WorldView::new(true);
diff --git a/gateway/src/world/handlers/loot.rs b/gateway/src/world/handlers/loot.rs
index 21cc7f12a..fd90fc6b9 100644
--- a/gateway/src/world/handlers/loot.rs
+++ b/gateway/src/world/handlers/loot.rs
@@ -554,6 +554,21 @@ pub(crate) fn handle_loot<St: WorldStore + ?Sized>(
                 );
             }
         }
+        // The death dialog's second button: use the Self-Resurrection Option the Module wrote into
+        // PLAYER_SELF_RES_SPELL. The revive replicates through the entity VALUES relay. A Refusal
+        // (already used, already alive) is expected after a race and sends nothing.
+        ClientOpcodeMessage::CMSG_SELF_RES => {
+            let self_guid = match &conn.state {
+                WorldState::InWorld(iw) => iw.self_guid,
+                WorldState::CharSelect => 0,
+            };
+            if let Err(e) = store.self_resurrect(conn.account_id, self_guid) {
+                log::debug!(
+                    "world: self_resurrect ignored (account {}): {e}",
+                    conn.account_id
+                );
+            }
+        }
         // Spirit-Healer resurrection: a ghost activated the graveyard Spirit Healer (npc_flags
         // SPIRITHEALER). The module res's in place at 50% + applies Resurrection Sickness; on success
         // reply with SMSG_SPIRIT_HEALER_CONFIRM (echoing the healer's guid) so the client closes the
diff --git a/gateway/src/world/store.rs b/gateway/src/world/store.rs
index 4d5df25cf..49396211f 100644
--- a/gateway/src/world/store.rs
+++ b/gateway/src/world/store.rs
@@ -1299,6 +1299,11 @@ pub trait WorldStore:
     /// for the caller) is expected when the offer already lapsed/was answered — per-action, log + ignore.
     fn resurrect_response(&self, account_id: u64, self_guid: u64, accept: bool) -> Result<()>;
 
+    /// Use the caller's Self-Resurrection Option (`CMSG_SELF_RES`): the module revives the dead
+    /// caller in place and spends the option. A Refusal (alive, or no option) is expected after a
+    /// race. Per-action: log and ignore.
+    fn self_resurrect(&self, account_id: u64, self_guid: u64) -> Result<()>;
+
     /// Spirit-Healer resurrect (`CMSG_SPIRIT_HEALER_ACTIVATE`): a ghost activates the graveyard Spirit
     /// Healer to res IN PLACE at 50% health/mana + a Resurrection Sickness debuff. `healer_guid` is the
     /// activated healer's guid (passed through to the confirm echo). The module gates on ghost state.
diff --git a/gateway/src/world/tests.rs b/gateway/src/world/tests.rs
index 817ca2127..b61551cc7 100644
--- a/gateway/src/world/tests.rs
+++ b/gateway/src/world/tests.rs
@@ -264,6 +264,7 @@ use wow_world_messages::vanilla::{
     CMSG_RECLAIM_CORPSE,
     CMSG_REPOP_REQUEST,
     CMSG_RESURRECT_RESPONSE,
+    CMSG_SELF_RES,
     CMSG_SETSHEATHED,
     CMSG_SET_SELECTION,
     CMSG_SPIRIT_HEALER_ACTIVATE,
@@ -853,6 +854,10 @@ struct InMemoryStore {
     /// Recorded `resurrect_response` calls — `(self_guid, accept)`, pinning the wire's
     /// `status != 0` → bool mapping.
     resurrect_responses: std::sync::Mutex<Vec<(u64, bool)>>,
+    /// Recorded `self_resurrect` calls: the caller's self_guid off CMSG_SELF_RES.
+    self_resurrects: std::sync::Mutex<Vec<u64>>,
+    /// When set, `self_resurrect` returns this Refusal after recording the call.
+    self_resurrect_error: Option<String>,
     /// Recorded `spirit_healer_res` calls — `(self_guid, healer_guid)` off
     /// CMSG_SPIRIT_HEALER_ACTIVATE.
     spirit_healer_calls: std::sync::Mutex<Vec<(u64, u64)>>,
@@ -3073,6 +3078,13 @@ impl WorldStore for InMemoryStore {
             .push((self_guid, accept));
         Ok(())
     }
+    fn self_resurrect(&self, _account_id: u64, self_guid: u64) -> Result<()> {
+        self.self_resurrects.lock().unwrap().push(self_guid);
+        match &self.self_resurrect_error {
+            Some(e) => Err(anyhow!("{e}")),
+            None => Ok(()),
+        }
+    }
     fn spirit_healer_res(&self, _account_id: u64, self_guid: u64, healer_guid: u64) -> Result<()> {
         self.spirit_healer_calls
             .lock()
@@ -12871,7 +12883,7 @@ fn gossip_keeps_the_train_and_unlearn_options_for_a_class_the_trainer_serves() {
 }
 
 // ── Death/resurrection dispatch (CMSG_REPOP_REQUEST / CMSG_RECLAIM_CORPSE /
-// CMSG_RESURRECT_RESPONSE / CMSG_SPIRIT_HEALER_ACTIVATE) ───────────────────────────────────────────
+// CMSG_RESURRECT_RESPONSE / CMSG_SELF_RES / CMSG_SPIRIT_HEALER_ACTIVATE) ───────────────────────────────────────────
 
 #[test]
 fn repop_request_dispatches_repop_for_the_caller() {
@@ -12940,6 +12952,42 @@ fn resurrect_response_decline_maps_status_byte_to_false() {
     );
 }
 
+#[test]
+fn self_res_dispatches_self_resurrect_for_the_caller() {
+    let store = std::sync::Arc::new(quest_store());
+    let (mut client, mut c_enc, _c_dec, server) = enter_world(store.clone(), 1);
+    CMSG_SELF_RES {}
+        .write_encrypted_client(&mut client, &mut c_enc)
+        .unwrap();
+    drop(client); // the revive replicates via the entity VALUES relay, not a direct SMSG here
+    server.join().unwrap();
+    assert_eq!(store.self_resurrects.lock().unwrap().as_slice(), &[1]);
+}
+
+#[test]
+fn a_refused_self_res_sends_nothing_and_keeps_the_session() {
+    let store = std::sync::Arc::new(InMemoryStore {
+        self_resurrect_error: Some("no Self-Resurrection Option".into()),
+        ..quest_store()
+    });
+    let (mut client, mut c_enc, mut c_dec, server) = enter_world(store.clone(), 1);
+    CMSG_SELF_RES {}
+        .write_encrypted_client(&mut client, &mut c_enc)
+        .unwrap();
+    CMSG_QUESTGIVER_STATUS_QUERY {
+        guid: Guid::new(50),
+    }
+    .write_encrypted_client(&mut client, &mut c_enc)
+    .unwrap();
+    match ServerOpcodeMessage::read_encrypted(&mut client, &mut c_dec).unwrap() {
+        ServerOpcodeMessage::SMSG_QUESTGIVER_STATUS(_) => {}
+        other => panic!("expected the sentinel (the Refusal sends nothing), got {other}"),
+    }
+    drop(client);
+    server.join().unwrap();
+    assert_eq!(store.self_resurrects.lock().unwrap().as_slice(), &[1]);
+}
+
 #[test]
 fn spirit_healer_activate_dispatches_and_confirms_the_healer_guid() {
     let store = std::sync::Arc::new(quest_store());
diff --git a/gateway/tests/schema_parity.rs b/gateway/tests/schema_parity.rs
index 1d3d140bb..79556f520 100644
--- a/gateway/tests/schema_parity.rs
+++ b/gateway/tests/schema_parity.rs
@@ -1086,6 +1086,9 @@ parity_test!(parity_game_creature_cast, "game_creature_cast", lyracore_module::C
 parity_test!(parity_game_resurrect_request, "game_resurrect_request", lyracore_module::ResurrectRequest, bindings::resurrect_request_type::ResurrectRequest, {
     target_guid, target_identity, caster_guid, caster_name, points, created_at,
 });
+parity_test!(parity_game_self_resurrect_option, "game_self_resurrect_option", lyracore_module::SelfResurrectOption, bindings::self_resurrect_option_type::SelfResurrectOption, {
+    character_guid, spell_id,
+});
 parity_test!(parity_game_aura, "game_aura", lyracore_module::Aura, bindings::aura_type::Aura, {
     id, target_guid, caster_guid, spell_id, slot, level, flags, applied_at, expires_at, effect_id,
     eff_kind, amount, eff_p0, eff_p0_kind, eff_p1, period_ms, amount_remaining, stacks,
@@ -1302,6 +1305,7 @@ const MANIFEST_TABLES: &[&str] = &[
     "game_spell_impact_event",
     "game_creature_cast",
     "game_resurrect_request",
+    "game_self_resurrect_option",
     "game_aura",
     "game_player_reputation",
     "game_character_contact",
diff --git a/importer/src/spell.rs b/importer/src/spell.rs
index ff9bce3e0..e76c2cd93 100644
--- a/importer/src/spell.rs
+++ b/importer/src/spell.rs
@@ -69,6 +69,7 @@ const E_DUEL: u8 = 0x22; // Duel (raw effect 83): p0 is the duel-flag gameobject
 const E_DISENCHANT: u8 = 0x18; // DISENCHANT (real Disenchant 13262, work-item 282): gateway-intercepted, routed to the disenchant reducer by kind. Mapped from raw vanilla effect 99 (SPELL_EFFECT_DISENCHANT); no params (the module validates + yields dust by item). Lockstep with the module taxonomy (module/src/spell/taxonomy.rs E_DISENCHANT).
 const E_DISMOUNT: u8 = 0x23; // remove the target's active land mount (Dazed's mount-removal half): translated from a raw DISPEL_MECHANIC effect (108) whose misc value names the mount mechanic (21) — see `dismount_effect_kind` below. No params. Lockstep with module taxonomy.
 const E_SUMMON_HOSTILE: u8 = 0x24; // temporary ownerless summon; p0 = creature entry, p1 = required spell focus, header duration = lifetime
+const E_SELF_RESURRECT: u8 = 0x26; // raw effect 94: base_points < 0 is flat health with p0 (P_FLAT_MANA) mana, else a percent of max; die_sides ignored (lockstep with module taxonomy)
 
 // cmangos/classic-db cd0c426a3b2ff56dd518bf009025299468e60fdb:
 // spell_template 7728/8674 send events 1131/1134; dbscripts_on_event summons
@@ -113,6 +114,7 @@ const A_MOUNTED: u8 = 0xB3; // land mount, the state of record (vanilla AuraMod
                             // aura 43, ProcTriggerDamage). p0 = the header's school_mask, p0_kind = P_SCHOOL_MASK (lockstep with
                             // module taxonomy).
 const A_PROC_DAMAGE: u8 = 0xB4;
+const A_SELF_RESURRECT: u8 = 0xB5; // Soulstone Resurrection: p0 (P_SPELL_ID) becomes the Self-Resurrection Option at death (lockstep with module taxonomy)
 
 // MECHANICS (p0 for A_CONTROL when p0_kind == P_MECHANIC)
 const M_STUN: i32 = 1;
@@ -136,6 +138,8 @@ const P_SPELLMOD_OP: u8 = 11; // p0 is a SpellModOp (A_SPELLMOD_*)
 const P_PCT_MAX_POWER: u8 = 12; // the effect's `amount` is a PERCENT of the caster's max power (Evocation); aura_apply converts it to an absolute per-tick (lockstep with module taxonomy)
 const P_GAMEOBJECT_ENTRY: u8 = 13; // p0 is a game_gameobject_template entry (E_DUEL)
 const P_DISPLAY_ID: u8 = 14; // p0 is a creature DISPLAY id (A_MOUNTED — the UNIT_FIELD_MOUNTDISPLAYID value)
+const P_SPELL_ID: u8 = 15; // p0 is a game_spell id (A_SELF_RESURRECT)
+const P_FLAT_MANA: u8 = 16; // p0 is a flat mana amount (E_SELF_RESURRECT)
 const P_RAW: u8 = 255;
 
 // TargetKind
@@ -452,6 +456,7 @@ fn instant_effect_to_kind(effect_id: i32) -> u8 {
         33 | 59 => E_OPEN_LOCK, // OpenLock (33) / OpenLockItem (59) — Pick Lock (work-item 119): gateway-intercepted, routed to the pick_lock reducer by kind (Pick Lock 1804 carries the raw OpenLock effect; the item-lock variant 59 covers a lockpick-on-item spell)
         99 => E_DISENCHANT, // Disenchant (13262, work-item 282): gateway-intercepted, routed to the disenchant reducer by kind — the AUTOLEARN enchanting ability. Was falling through to E_SCRIPTED (a no-op).
         80 => E_ADD_COMBO, // AddComboPoints (work-item 101) — the curated Rogue generators (Sinister Strike/Backstab/Gouge/Garrote) carry the generic Dummy effect in-kit and are rescued BY NAME in correct_script_effect_kind below, not via this raw id, so this arm is currently unexercised by the curated kit but correct for any spell that DOES carry the raw AddComboPoints effect
+        94 => E_SELF_RESURRECT, // SelfResurrect (Soulstone Resurrection, Reincarnation): read by the Module's self-resurrection, never cast
         18 | 113 => E_RESURRECT, // Resurrect / ResurrectNew (work-item 101) — the curated kit's two resurrects (Priest Resurrection 2006, Paladin Redemption 7328) are ALSO rescued by name below; if either carries raw effect 18/113 in the real DBC (plausible — that is literally what the effect exists for) this arm now resolves them natively too, moving them out of `cov.unmapped_effect` even though the final kind was already E_RESURRECT via the name rescue either way — unverified without a client DBC dump, so [V]
         _ => E_SCRIPTED,         // remaining vanilla effects: queryable no-op
     }
@@ -540,10 +545,26 @@ fn correct_script_effect_kind(name: &str, kind: u8) -> u8 {
         | "Create Healthstone (Lesser)"
         | "Create Healthstone (Greater)"
         | "Create Healthstone (Major)" => E_CREATE_ITEM,
+        // Every Soulstone rank's buff is a Dummy aura; its rank picks the option spell below.
+        "Soulstone Resurrection" => A_SELF_RESURRECT,
         _ => kind,
     }
 }
 
+/// The Self-Resurrection Option spell each Soulstone Resurrection aura rank grants. The ranks share
+/// one name, so the aura spell id decides. Source: ClassicDB 1.12.1 `spell_template` at the pinned
+/// commit, cross-checked against cmangos-classic `Player::GetResurrectionSpellId`.
+fn soulstone_option_spell(aura_spell_id: u32) -> Option<i32> {
+    match aura_spell_id {
+        20707 => Some(3026),
+        20762 => Some(20758),
+        20763 => Some(20759),
+        20764 => Some(20760),
+        20765 => Some(20761),
+        _ => None,
+    }
+}
+
 /// Translate the vanilla Spell.dbc `Stances` (ShapeshiftMask) bitmask → our 0-based stance usability bits.
 /// Vanilla stores bit `1 << (formId-1)` for each allowed form; every form `form_to_stance` maps (the
 /// Warrior trio AND, since work-item 156, the Druid combat forms Bear/Cat/Dire Bear) folds onto our bit
@@ -904,6 +925,7 @@ fn resolve_instant_params(kind: u8, misc: u32, item_type: i32) -> (i32, u8) {
         // Summon names a creature template in EffectMiscValue.
         E_SUMMON_PET => (misc as i32, P_ENTRY),
         E_DUEL => (misc as i32, P_GAMEOBJECT_ENTRY),
+        E_SELF_RESURRECT => (misc as i32, P_FLAT_MANA),
         _ => (0, P_NONE), // damage/heal/trigger/taunt school is on the header; no p0
     }
 }
@@ -1628,6 +1650,12 @@ fn resolve_effect_kind(
         (p0, p0_kind)
     };
 
+    let (p0, p0_kind) = if kind == A_SELF_RESURRECT {
+        (soulstone_option_spell(s.id).unwrap_or(0), P_SPELL_ID)
+    } else {
+        (p0, p0_kind)
+    };
+
     let base_points = dbc_flat_amount(s.effect_base_points[i]); // DBC +1 convention (mounted-speed 59/99 → 60/100 falls out of this for free)
                                                                 // Avoidance-chance combat fields are basis-points in our engine but PERCENT in the DBC, so
                                                                 // scale ×100 (Evasion's +50% dodge → +5000 bp). COMBAT_THREAT is a signed percent in both
@@ -1701,7 +1729,8 @@ fn resolve_effect_target(s: &Spell, i: usize, kind: u8, header: &SpellHeader) ->
         E_CHARGE | E_JUDGEMENT | E_PICKPOCKET | E_INTERRUPT | E_NEXT_SWING | E_TAUNT
         | E_TAME_CREATURE => T_TARGET_ENEMY,
         E_RESURRECT => T_TARGET_ALLY,
-        E_REDUCE_THREAT | E_BLINK | E_PERSISTENT_AREA | E_SUMMON_PET | E_SUMMON_HOSTILE => T_SELF,
+        E_REDUCE_THREAT | E_BLINK | E_PERSISTENT_AREA | E_SUMMON_PET | E_SUMMON_HOSTILE
+        | E_SELF_RESURRECT => T_SELF,
         E_DUEL => T_TARGET_ANY,
         _ => target,
     };
@@ -2007,6 +2036,7 @@ fn kind_name(kind: u8) -> &'static str {
         E_FEED_PET => "E_FEED_PET",
         E_POWER_BURN => "E_POWER_BURN",
         E_DUEL => "E_DUEL",
+        E_SELF_RESURRECT => "E_SELF_RESURRECT",
         E_SCRIPTED => "E_SCRIPTED",
         A_PERIODIC_DAMAGE => "A_PERIODIC_DAMAGE",
         A_PERIODIC_HEAL => "A_PERIODIC_HEAL",
@@ -2024,6 +2054,7 @@ fn kind_name(kind: u8) -> &'static str {
         A_FLAG => "A_FLAG",
         A_PROC_TRIGGER => "A_PROC_TRIGGER",
         A_PROC_DAMAGE => "A_PROC_DAMAGE",
+        A_SELF_RESURRECT => "A_SELF_RESURRECT",
         _ => "?",
     }
 }
@@ -2994,6 +3025,104 @@ mod tests {
         );
     }
 
+    /// ClassicDB 1.12.1 `spell_template`: each Soulstone Resurrection aura rank (Dummy aura, friendly
+    /// target) and the self-resurrect spell it grants (raw effect 94, raw base = -(health + 1), misc =
+    /// mana).
+    const SOULSTONE_RANKS: [(u32, u32, i32, u32); 5] = [
+        (20707, 3026, -401, 700),
+        (20762, 20758, -751, 1200),
+        (20763, 20759, -1101, 1700),
+        (20764, 20760, -1601, 2200),
+        (20765, 20761, -2201, 2800),
+    ];
+
+    fn soulstone_aura(id: u32) -> Spell {
+        Spell {
+            id,
+            name: "Soulstone Resurrection".into(),
+            effect: [EFFECT_APPLY_AURA, 0, 0],
+            effect_aura: [AuraMod::Dummy as u32, 0, 0],
+            implicit_target_a: [21, 0, 0],
+            ..Default::default()
+        }
+    }
+
+    fn self_resurrect_spell(id: u32, raw_base: i32, misc: u32) -> Spell {
+        Spell {
+            id,
+            name: "Use Soulstone".into(),
+            effect: [94, 0, 0],
+            effect_base_points: [raw_base, 0, 0],
+            effect_die_sides: [1, 0, 0],
+            effect_misc_value: [misc, 0, 0],
+            implicit_target_a: [1, 0, 0],
+            ..Default::default()
+        }
+    }
+
+    fn first_effect(rows: &SpellRows, spell_id: u32) -> &SpellEffectRow {
+        rows.effects
+            .iter()
+            .find(|effect| effect.spell_id == spell_id)
+            .unwrap()
+    }
+
+    #[test]
+    fn every_soulstone_aura_rank_names_its_self_resurrect_spell() {
+        let mut dbc = fixture_tables();
+        dbc.spells = SOULSTONE_RANKS
+            .iter()
+            .map(|&(aura, ..)| soulstone_aura(aura))
+            .chain([soulstone_aura(999_998)])
+            .collect();
+
+        let (rows, _, _) = derive_spell_rows(&dbc, &[], &[]).unwrap();
+        for (aura, option, ..) in SOULSTONE_RANKS {
+            let effect = first_effect(&rows, aura);
+            assert_eq!(
+                (effect.kind, effect.p0, effect.p0_kind),
+                (A_SELF_RESURRECT, option as i32, P_SPELL_ID),
+                "aura rank {aura}"
+            );
+        }
+        let unknown = first_effect(&rows, 999_998);
+        assert_eq!((unknown.kind, unknown.p0), (A_SELF_RESURRECT, 0));
+    }
+
+    #[test]
+    fn self_resurrect_effects_keep_the_vanilla_sign_rule() {
+        let mut dbc = fixture_tables();
+        dbc.spells = SOULSTONE_RANKS
+            .iter()
+            .map(|&(_, option, raw_base, mana)| self_resurrect_spell(option, raw_base, mana))
+            .chain([self_resurrect_spell(21169, 19, 0)])
+            .collect();
+
+        let (rows, _, _) = derive_spell_rows(&dbc, &[], &[]).unwrap();
+        let expected = [
+            (3026, -400, 700),
+            (20758, -750, 1200),
+            (20759, -1100, 1700),
+            (20760, -1600, 2200),
+            (20761, -2200, 2800),
+            (21169, 20, 0),
+        ];
+        for (spell_id, base_points, mana) in expected {
+            let effect = first_effect(&rows, spell_id);
+            assert_eq!(
+                (
+                    effect.kind,
+                    effect.base_points,
+                    effect.p0,
+                    effect.p0_kind,
+                    effect.target
+                ),
+                (E_SELF_RESURRECT, base_points, mana, P_FLAT_MANA, T_SELF),
+                "spell {spell_id}"
+            );
+        }
+    }
+
     #[test]
     fn stance_p0_remaps_form_id_to_zero_based_stance() {
         // The effect-loop remap turns the vanilla form id (carried in p0 by the A_FLAG marker) into our
diff --git a/module/src/actor.rs b/module/src/actor.rs
index 86c5f1673..0d5c678fa 100644
--- a/module/src/actor.rs
+++ b/module/src/actor.rs
@@ -45,6 +45,7 @@
 //! | `repop` | `world::do_repop` | dead actor releases to the graveyard ghost |
 //! | `respond_resurrect` | `spell::do_resurrect_response` | consume the actor's pending rez offer; accept revives IN PLACE at the offer's % |
 //! | `spirit_res` | `world::do_spirit_healer_res` | ghost actor res at the spirit healer (sickness applies) |
+//! | `self_resurrect` | `spell::do_self_resurrect` | dead actor with a Self-Resurrection Option revives in place; no sickness |
 //! | `accept_group_invite` | `group::accept_invite_for` | pending invite exists + its Group still exists (or a solo inviter is still ungrouped) + group not full; roster events fire |
 //! | `set_sessionless_action_consent` | `sessionless::set_sessionless_action_consent` | update Package consent and clear unclaimed Group Intents atomically |
 //! | `companion_target_facts` | `group::companion_target_facts` | exact hostile creature + partition/death/control gates; never selects a substitute |
@@ -192,6 +193,7 @@ package_only! {
     pub(crate) use crate::spell::do_resurrect_response as respond_resurrect;
     pub(crate) use crate::world::do_repop as repop;
     pub(crate) use crate::world::do_spirit_healer_res as spirit_res;
+    pub(crate) use crate::spell::do_self_resurrect as self_resurrect;
 }
 
 // ---- social ----
diff --git a/module/src/combat/death.rs b/module/src/combat/death.rs
index f3cb76083..01529be9d 100644
--- a/module/src/combat/death.rs
+++ b/module/src/combat/death.rs
@@ -840,7 +840,9 @@ pub(crate) fn kill_player(ctx: &ReducerContext, victim_guid: u64, killer_guid: u
     crate::spell::break_channel(ctx, victim_guid);
     // Dying sheds the auras vanilla does not exempt, and converges every projection they fed. A rider
     // who dies is dismounted HERE, by ordinary aura removal — the corpse must not keep its mount, its
-    // buffs, or the crowd control that was on it.
+    // buffs, or the crowd control that was on it. The Self-Resurrection Option is read first: the
+    // Soulstone aura that grants it does not survive the shed.
+    crate::spell::record_self_resurrect_option(ctx, victim_guid);
     crate::spell::remove_auras_on_death(ctx, victim_guid);
     // A live Trade Session dies with the victim — both windows hear `TradeCanceled`.
     crate::trade::cancel_trade_for(ctx, victim_guid);
diff --git a/module/src/corpse.rs b/module/src/corpse.rs
index d8960da75..38ab6597a 100644
--- a/module/src/corpse.rs
+++ b/module/src/corpse.rs
@@ -8,7 +8,6 @@ use spacetimedb::{table, ReducerContext, Table, Timestamp};
 use lyracore_shared::packing::unpack4;
 
 use crate::game_world_entity;
-use crate::spell::game_resurrect_request;
 
 /// HIGHGUID_CORPSE high bits (0xF101): marks a guid as a corpse object for the 5875 client. The
 /// corpse guid is `(HIGHGUID_CORPSE << 48) | owner_guid_low`, so one corpse per player at a time.
@@ -232,13 +231,7 @@ pub(crate) fn apply_reclaim_corpse(
     entities.guid().update(player);
     corpses.guid().delete(corpse_guid);
 
-    // Reclaiming resolves the death outside of accepting a pending resurrect offer — drop any
-    // outstanding `game_resurrect_request` for this player so a stale offer doesn't resurface as a
-    // phantom SMSG_RESURRECT_REQUEST on a future reconnect. Idempotent (no-op if none pending).
-    ctx.db
-        .game_resurrect_request()
-        .target_guid()
-        .delete(player_guid);
+    crate::spell::clear_resurrect_request_and_option(ctx, player_guid);
     Ok(())
 }
 
diff --git a/module/src/debug/mod.rs b/module/src/debug/mod.rs
index 0fbb13f16..a3805487b 100644
--- a/module/src/debug/mod.rs
+++ b/module/src/debug/mod.rs
@@ -265,6 +265,13 @@ pub fn debug_spirit_healer_res(ctx: &ReducerContext, character_guid: u64) -> Res
     crate::actor::spirit_res(ctx, character_guid)
 }
 
+/// Use the Self-Resurrection Option by explicit guid (the `CMSG_SELF_RES` path). Errors if the
+/// Character is alive or holds no option.
+#[reducer]
+pub fn debug_self_resurrect(ctx: &ReducerContext, character_guid: u64) -> Result<(), String> {
+    crate::actor::self_resurrect(ctx, character_guid)
+}
+
 /// Answer a pending resurrect offer by explicit guid (`CMSG_RESURRECT_RESPONSE` / `resurrect_response`
 /// path) — drives the shared `do_resurrect_response` core against the row directly (the CLI
 /// identity owns no entity), so the parent can verify the accept-prompt handshake headlessly. Errors if
diff --git a/module/src/gw.rs b/module/src/gw.rs
index 5ae08ba4a..be142c3f3 100644
--- a/module/src/gw.rs
+++ b/module/src/gw.rs
@@ -607,6 +607,18 @@ pub fn gw_repop(ctx: &ReducerContext, request_actor: crate::SessionActor) -> Res
     crate::actor::repop(ctx, actor_guid)
 }
 
+/// [`crate::actor::self_resurrect`] behind the gateway gate: use the Self-Resurrection Option.
+#[reducer]
+pub fn gw_self_resurrect(
+    ctx: &ReducerContext,
+    request_actor: crate::SessionActor,
+) -> Result<(), String> {
+    require_operator(ctx)?;
+    let actor_guid = crate::account_ownership::require_actor(ctx, request_actor)?;
+    actor(ctx, actor_guid)?;
+    crate::actor::self_resurrect(ctx, actor_guid)
+}
+
 /// [`crate::actor::spirit_res`] behind the gateway gate — ghost res at the spirit healer.
 #[reducer]
 pub fn gw_spirit_res(
diff --git a/module/src/spell/cast/targeting.rs b/module/src/spell/cast/targeting.rs
index c99e76661..ee76ec4be 100644
--- a/module/src/spell/cast/targeting.rs
+++ b/module/src/spell/cast/targeting.rs
@@ -878,6 +878,14 @@ pub(crate) fn apply_effect(
             apply_character_effect(ctx, e, caster_guid, target_guid, points)
         }
         E_TRIGGER | E_SCRIPTED => apply_delegating_effect(ctx, e, caster_guid, target_guid, level),
+        E_SELF_RESURRECT => {
+            // Only `do_self_resurrect` reads this effect; the cast pipeline refuses dead casters.
+            log::info!(
+                "spell {} self-resurrect effect has no cast path (no-op)",
+                e.spell_id
+            );
+            EffectHit::none()
+        }
         E_DISPEL => {
             // The dispelled CATEGORY: the effect's `p0` (the authored override) if set, else the
             // dispelling spell's header `dispel_type`. 0 = strip every foreign aura (the baseline —
diff --git a/module/src/spell/mod.rs b/module/src/spell/mod.rs
index c07bafdea..a3097632e 100644
--- a/module/src/spell/mod.rs
+++ b/module/src/spell/mod.rs
@@ -27,6 +27,7 @@
 //!   `begin_cast` / the passive-apply path).
 //! - `proc`      — the Proc engine: the pure proc decision plus the ONE pass, from `apply_hit`.
 //! - `scheduler` — the `#[reducer]`s (`tick_auras` / `fire_pending_cast` / `cast_spell`).
+//! - `self_resurrect`: the Self-Resurrection Option, chosen at death and used from the death dialog.
 //!
 //! Everything is re-exported below so every `crate::spell::<sym>` path resolves regardless of which
 //! submodule actually defines it.
@@ -39,6 +40,7 @@ mod effects;
 mod math;
 pub(crate) mod proc;
 mod scheduler;
+mod self_resurrect;
 pub(crate) mod spellbook;
 pub(crate) mod stacking;
 mod tables;
@@ -55,6 +57,7 @@ pub use control::*;
 pub(crate) use effects::*;
 pub use math::*;
 pub use scheduler::*;
+pub(crate) use self_resurrect::*;
 pub use spellbook::*;
 pub use tables::*;
 pub(crate) use taxonomy::*;
diff --git a/module/src/spell/scheduler.rs b/module/src/spell/scheduler.rs
index b4c254b5b..13d46c80c 100644
--- a/module/src/spell/scheduler.rs
+++ b/module/src/spell/scheduler.rs
@@ -235,6 +235,7 @@ pub(crate) fn do_resurrect_response(
                 t.player_flags &= !lyracore_shared::constants::player_flags::GHOST;
                 t.unit_bytes_1 &= !lyracore_shared::constants::unit_vis_flags::GHOST;
                 ctx.db.game_world_entity().guid().update(t);
+                crate::spell::clear_resurrect_request_and_option(ctx, target_guid);
             }
         }
     }
diff --git a/module/src/spell/self_resurrect.rs b/module/src/spell/self_resurrect.rs
new file mode 100644
index 000000000..3c654255a
--- /dev/null
+++ b/module/src/spell/self_resurrect.rs
@@ -0,0 +1,169 @@
+//! Self-resurrection: the Self-Resurrection Option a dead Character holds, and its use.
+//!
+//! The option is chosen once, at death, from the Character's `A_SELF_RESURRECT` auras (a Soulstone).
+//! Those auras do not survive death, so the option row is the only record that remains. Using the
+//! option reads the named spell's `E_SELF_RESURRECT` effect and revives the Character in place, with
+//! no Resurrection Sickness.
+
+use lyracore_shared::constants::{player_flags, unit_vis_flags};
+use lyracore_shared::packing::power_type;
+use spacetimedb::{ReducerContext, Table};
+
+use super::{
+    auras_on, game_resurrect_request, game_self_resurrect_option, game_spell_effect,
+    SelfResurrectOption, A_SELF_RESURRECT, E_SELF_RESURRECT,
+};
+use crate::{game_corpse, game_world_entity};
+
+/// Choose `character_guid`'s Self-Resurrection Option from its auras. Call it at death, before the
+/// death aura shed removes the Soulstone aura. The highest `A_SELF_RESURRECT` spell wins. Without one,
+/// any row left from an earlier death is deleted, so a stale option never outlives its source.
+pub(crate) fn record_self_resurrect_option(ctx: &ReducerContext, character_guid: u64) {
+    let chosen = auras_on(ctx, character_guid)
+        .filter(|a| a.eff_kind == A_SELF_RESURRECT && a.eff_p0 > 0)
+        .map(|a| a.eff_p0 as u32)
+        .max();
+    let options = ctx.db.game_self_resurrect_option();
+    options.character_guid().delete(character_guid);
+    if let Some(spell_id) = chosen {
+        options.insert(SelfResurrectOption {
+            character_guid,
+            spell_id,
+        });
+    }
+}
+
+/// Use `character_guid`'s Self-Resurrection Option: revive in place at the option spell's vitals,
+/// clear the dead and ghost state, remove the corpse, and spend the option. One transaction. A
+/// Refusal (not in the world, not dead, no option, or an option spell without an
+/// `E_SELF_RESURRECT` effect) changes nothing.
+pub(crate) fn do_self_resurrect(ctx: &ReducerContext, character_guid: u64) -> Result<(), String> {
+    let entities = ctx.db.game_world_entity();
+    let mut character = entities
+        .guid()
+        .find(character_guid)
+        .ok_or_else(|| "caller not in world".to_string())?;
+    if !character.dead {
+        return Err("caller is not dead".to_string());
+    }
+    let option = ctx
+        .db
+        .game_self_resurrect_option()
+        .character_guid()
+        .find(character_guid)
+        .ok_or_else(|| "no Self-Resurrection Option".to_string())?;
+    let effect = ctx
+        .db
+        .game_spell_effect()
+        .by_spell()
+        .filter(&option.spell_id)
+        .find(|e| e.kind == E_SELF_RESURRECT)
+        .ok_or_else(|| format!("spell {} has no self-resurrect effect", option.spell_id))?;
+
+    let (health, power) = self_resurrect_vitals(
+        character.max_health,
+        character.max_power,
+        power_type::for_class(character.class()),
+        effect.base_points,
+        effect.p0,
+    );
+    character.health = health;
+    character.power = power;
+    character.dead = false;
+    character.player_flags &= !player_flags::GHOST;
+    character.unit_bytes_1 &= !unit_vis_flags::GHOST;
+    entities.guid().update(character);
+    ctx.db
+        .game_corpse()
+        .guid()
+        .delete(crate::corpse::corpse_guid_for(character_guid));
+    clear_resurrect_request_and_option(ctx, character_guid);
+    Ok(())
+}
+
+/// The health and power a self-resurrection restores, per the `E_SELF_RESURRECT` rule: a negative
+/// `base_points` is a flat health amount with `flat_mana` mana, otherwise a percent of max health and
+/// max mana. Health lands in `1..=max_health`. A mana user gets the computed mana capped at its max,
+/// an energy user a full bar, and every other power type 0.
+pub(crate) fn self_resurrect_vitals(
+    max_health: u32,
+    max_power: u32,
+    power_kind: u8,
+    base_points: i32,
+    flat_mana: i32,
+) -> (u32, u32) {
+    let percent_of =
+        |max: u32| (u64::from(max) * u64::from(base_points.unsigned_abs()) / 100) as u32;
+    let (health, mana) = if base_points < 0 {
+        (base_points.unsigned_abs(), flat_mana.max(0) as u32)
+    } else {
+        (percent_of(max_health), percent_of(max_power))
+    };
+    let power = match power_kind {
+        power_type::MANA => mana.min(max_power),
+        power_type::ENERGY => max_power,
+        _ => 0,
+    };
+    (health.min(max_health).max(1), power)
+}
+
+/// Delete `character_guid`'s pending resurrect request from another Character. Release Spirit uses
+/// this alone: a ghost keeps its Self-Resurrection Option.
+pub(crate) fn clear_resurrect_request(ctx: &ReducerContext, character_guid: u64) {
+    ctx.db
+        .game_resurrect_request()
+        .target_guid()
+        .delete(character_guid);
+}
+
+/// Delete both ways back `character_guid` may hold: the resurrect request and the
+/// Self-Resurrection Option. Every resurrection and leaving the world use this.
+pub(crate) fn clear_resurrect_request_and_option(ctx: &ReducerContext, character_guid: u64) {
+    clear_resurrect_request(ctx, character_guid);
+    ctx.db
+        .game_self_resurrect_option()
+        .character_guid()
+        .delete(character_guid);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::self_resurrect_vitals;
+    use lyracore_shared::packing::power_type::{ENERGY, MANA, RAGE};
+
+    /// Minor Soulstone (3026): raw base -401, so 400 health and its 700 mana, capped at max mana.
+    #[test]
+    fn a_negative_base_is_flat_health_and_flat_mana() {
+        assert_eq!(
+            self_resurrect_vitals(1000, 600, MANA, -400, 700),
+            (400, 600)
+        );
+        assert_eq!(
+            self_resurrect_vitals(1000, 2000, MANA, -400, 700),
+            (400, 700)
+        );
+    }
+
+    /// Reincarnation (21169): raw base 19, so 20 percent of max health and max mana.
+    #[test]
+    fn a_positive_base_is_a_percent_of_max() {
+        assert_eq!(self_resurrect_vitals(1000, 600, MANA, 20, 0), (200, 120));
+    }
+
+    #[test]
+    fn health_stays_within_one_and_max() {
+        assert_eq!(self_resurrect_vitals(0, 0, MANA, -400, 700), (1, 0));
+        assert_eq!(self_resurrect_vitals(300, 0, MANA, -400, 700), (300, 0));
+        assert_eq!(self_resurrect_vitals(1000, 600, MANA, 0, 0), (1, 0));
+    }
+
+    #[test]
+    fn rage_comes_back_empty_and_energy_full() {
+        assert_eq!(self_resurrect_vitals(1000, 1000, RAGE, -400, 700), (400, 0));
+        assert_eq!(
+            self_resurrect_vitals(1000, 100, ENERGY, -400, 700),
+            (400, 100)
+        );
+        assert_eq!(self_resurrect_vitals(1000, 100, ENERGY, 20, 0), (200, 100));
+    }
+}
diff --git a/module/src/spell/tables.rs b/module/src/spell/tables.rs
index 785405303..022b484da 100644
--- a/module/src/spell/tables.rs
+++ b/module/src/spell/tables.rs
@@ -783,3 +783,14 @@ pub struct ResurrectRequest {
     pub points: i32,         // frozen E_RESURRECT base_points (%), applied on accept
     pub created_at: Timestamp,
 }
+
+/// The Self-Resurrection Option a dead Character holds: the one spell it may cast on itself. Chosen at
+/// death, kept through Release Spirit, and deleted when the Character is resurrected or leaves the
+/// world. The Gateway writes `spell_id` into the owner's `PLAYER_SELF_RES_SPELL` and sends it to the
+/// owner only.
+#[table(accessor = game_self_resurrect_option, public)]
+pub struct SelfResurrectOption {
+    #[primary_key]
+    pub character_guid: u64,
+    pub spell_id: u32,
+}
diff --git a/module/src/spell/taxonomy.rs b/module/src/spell/taxonomy.rs
index a9c4dde54..710a85780 100644
--- a/module/src/spell/taxonomy.rs
+++ b/module/src/spell/taxonomy.rs
@@ -116,6 +116,13 @@ pub(crate) const E_DUEL: u8 = 0x22; // Duel (raw effect 83): request a server-au
 /// implements a generic mechanic dispel and never branches on spell 1604 or a spell name.
 pub(crate) const E_DISMOUNT: u8 = 0x23;
 pub(crate) const E_SUMMON_HOSTILE: u8 = 0x24; // temporary ownerless summon; p0 = creature entry, p1 = required spell focus, header duration = lifetime
+/// Self-resurrection (vanilla raw effect 94). No cast runs it: [`do_self_resurrect`] reads this row
+/// from the spell a Self-Resurrection Option names. `base_points < 0` restores `-base_points` health and
+/// `p0` ([`P_FLAT_MANA`]) mana. `base_points >= 0` restores that percent of max health and max mana.
+/// `die_sides` is ignored, because every vanilla row carries a one-sided die that would add 1.
+///
+/// [`do_self_resurrect`]: crate::spell::do_self_resurrect
+pub(crate) const E_SELF_RESURRECT: u8 = 0x26;
 
 pub(crate) const E_POWER_BURN: u8 = 0x19; // drain N mana from the target and deal a fraction of it as damage (Mana Burn): MANA-power-type gate read off the target's `unit_bytes_0` byte 3 (same read as `is_rage_user`) — a rage/energy target is a silent no-op (power AND health untouched), matching vanilla's behaviour of skipping the effect entirely. drained = min(base_points, target.power) (floor-at-available; an empty/low pool just burns less, never fails the cast). damage = drained * p1 / 100 (p1 = the effect's ratio in basis-points — vanilla Mana Burn is EffectMultipleValue=0.5 -> p1=50 -> half the drained mana as Shadow damage); `p1<=0` (unauthored data) defaults to 100 (1:1), so a missing p1 never silently zeroes all burn damage. Dealt via the shared `apply_target_damage` (threat/kill/absorb reuse, no new wire work)
 
@@ -193,6 +200,9 @@ pub(crate) const A_MOD_DETECT_RANGE: u8 = 0xB2;
 /// means display 0. A normal cancelable self aura: expiry, `CMSG_CANCEL_AURA`, dispel and `E_DISMOUNT`
 /// all converge on the same recompute.
 pub(crate) const A_MOUNTED: u8 = 0xB3;
+/// Soulstone Resurrection: while this aura is on a Character at death, its `p0` ([`P_SPELL_ID`]) becomes
+/// the Character's Self-Resurrection Option. The aura itself does not survive death.
+pub(crate) const A_SELF_RESURRECT: u8 = 0xB5;
 pub(crate) const A_FLAG: u8 = 0xBE; // passive marker aura (no tick), p0 = flag id
 
 /// Documented tuning approximation for `combat::swing_range_ctx`: a DISARMED creature has no weapon/unarmed
@@ -249,6 +259,8 @@ pub(crate) const P_GAMEOBJECT_ENTRY: u8 = 13; // p0 is a game_gameobject_templat
 /// The importer resolves a mount spell's creature template to its display once, at import, and freezes
 /// the result here; the runtime only reads it.
 pub(crate) const P_DISPLAY_ID: u8 = 14;
+pub(crate) const P_SPELL_ID: u8 = 15; // p0 is a game_spell id (A_SELF_RESURRECT: the Self-Resurrection Option)
+pub(crate) const P_FLAT_MANA: u8 = 16; // p0 is a flat mana amount (E_SELF_RESURRECT with negative base_points)
 pub(crate) const P_RAW: u8 = 255; // scripted / unresolved
 
 // --- TargetKind: who the effect resolves onto ---
@@ -412,6 +424,7 @@ pub(crate) const ALL_INSTANT_KINDS: &[u8] = &[
     E_TAME_CREATURE,
     E_FEED_PET,
     E_DISMOUNT,
+    E_SELF_RESURRECT,
 ];
 
 /// Canonical, ordered list of every AURA (`A_*`) kind — same rationale and same fix as
@@ -444,6 +457,7 @@ pub(crate) const ALL_AURA_KINDS: &[u8] = &[
     A_IMMUNITY,
     A_MOD_DETECT_RANGE,
     A_MOUNTED,
+    A_SELF_RESURRECT,
     A_FLAG,
 ];
 
@@ -454,7 +468,7 @@ pub(crate) const ALL_AURA_KINDS: &[u8] = &[
 // own. A subset of it has no OTHER production call site yet though (only a test-only reference, same as
 // every `E_*`/`A_*` kind before `ALL_INSTANT_KINDS`/`ALL_AURA_KINDS` existed), so it still needs SOME
 // aggregate to keep `dead_code` from tripping on the non-test `lib` build. It holds just the residue,
-// down from `_TAXONOMY`'s ~100 entries to these 18.
+// down from `_TAXONOMY`'s ~100 entries to these 20.
 #[allow(dead_code)]
 const _RESERVED_NON_KIND_TAXONOMY: &[u8] = &[
     P_NONE,
@@ -469,6 +483,8 @@ const _RESERVED_NON_KIND_TAXONOMY: &[u8] = &[
     P_ENCHANT_ID,
     P_SPELLMOD_OP,
     P_DISPLAY_ID,
+    P_SPELL_ID,
+    P_FLAT_MANA,
     P_RAW,
     T_SCRIPTED,
     SPEED_CAST,
diff --git a/module/src/spell/tests.rs b/module/src/spell/tests.rs
index 1629922bd..3f6649707 100644
--- a/module/src/spell/tests.rs
+++ b/module/src/spell/tests.rs
@@ -498,7 +498,7 @@ fn kind_wire_values() {
 fn instant_kind_wire_values_exhaustive() {
     assert_eq!(
         ALL_INSTANT_KINDS.len(),
-        35,
+        36,
         "an instant kind was added to (or removed from) taxonomy.rs without a matching, deliberate \
          change to ALL_INSTANT_KINDS — bump this count only when the taxonomy really changed"
     );
@@ -533,7 +533,7 @@ fn instant_kind_wire_values_exhaustive() {
 fn aura_kind_wire_values_exhaustive() {
     assert_eq!(
         ALL_AURA_KINDS.len(),
-        26,
+        27,
         "an aura kind was added to (or removed from) taxonomy.rs without a matching, deliberate \
          change to ALL_AURA_KINDS — bump this count only when the taxonomy really changed"
     );
@@ -588,7 +588,7 @@ fn apply_spell_auras_still_calls_the_passive_effect_filter() {
 
 /// Pin EVERY `P_*` param-tag value (`eff_p0_kind` — what `p0` MEANS on a given effect/aura row): the
 /// importer stamps these BY NAME and the readers (`resistance_bonus`, `is_immune_to_mechanic`, …) key off
-/// them, so a drift here would silently reinterpret a frozen `p0`. All 15 are distinct.
+/// them, so a drift here would silently reinterpret a frozen `p0`. All 17 are distinct.
 #[test]
 fn param_tag_wire_values_exhaustive() {
     assert_eq!(P_NONE, 0);
@@ -605,6 +605,8 @@ fn param_tag_wire_values_exhaustive() {
     assert_eq!(P_PCT_MAX_POWER, 12);
     assert_eq!(P_GAMEOBJECT_ENTRY, 13);
     assert_eq!(P_DISPLAY_ID, 14);
+    assert_eq!(P_SPELL_ID, 15);
+    assert_eq!(P_FLAT_MANA, 16);
     assert_eq!(P_RAW, 255);
     let all = [
         P_NONE,
@@ -621,6 +623,8 @@ fn param_tag_wire_values_exhaustive() {
         P_PCT_MAX_POWER,
         P_GAMEOBJECT_ENTRY,
         P_DISPLAY_ID,
+        P_SPELL_ID,
+        P_FLAT_MANA,
         P_RAW,
     ];
     for (i, a) in all.iter().enumerate() {
diff --git a/module/src/tripwires.rs b/module/src/tripwires.rs
index e34f94df0..d4613aa04 100644
--- a/module/src/tripwires.rs
+++ b/module/src/tripwires.rs
@@ -133,6 +133,7 @@ pub(crate) mod character_owned_tripwire {
                 "game_ranged_impact_schedule",
                 "game_resurrect_request",
                 "game_school_lockout",
+                "game_self_resurrect_option",
                 "game_spell_cd",
                 "game_spell_cooldown",
             ],
diff --git a/module/src/world.rs b/module/src/world.rs
index 8ef57a970..49090b753 100644
--- a/module/src/world.rs
+++ b/module/src/world.rs
@@ -12,7 +12,6 @@ use crate::faction::game_faction_template;
 // alias keeps every `graveyard::...` call site below byte-identical.
 use crate::graveyard;
 use crate::helpers::entity_by_owner;
-use crate::spell::game_resurrect_request;
 use crate::{
     game_character, game_character_buyback, game_corpse, game_creature_spline, game_instance,
 };
@@ -1899,13 +1898,9 @@ pub(crate) fn do_repop(ctx: &ReducerContext, guid: u64) -> Result<(), String> {
     // itself inside a dungeon instance.
     teleport_player(ctx, player_guid, gy.map, 0, gy.x, gy.y, gy.z, gy.o);
 
-    // Releasing to spirit resolves the death outside of accepting a pending resurrect offer —
-    // drop any outstanding `game_resurrect_request` for this target so a stale offer doesn't resurface
-    // as a phantom SMSG_RESURRECT_REQUEST on a future reconnect. Idempotent (no-op if none pending).
-    ctx.db
-        .game_resurrect_request()
-        .target_guid()
-        .delete(player_guid);
+    // Releasing to spirit drops a pending resurrect offer so it cannot resurface as a phantom
+    // SMSG_RESURRECT_REQUEST on a future reconnect. The ghost keeps its Self-Resurrection Option.
+    crate::spell::clear_resurrect_request(ctx, player_guid);
     Ok(())
 }
 
@@ -2057,10 +2052,7 @@ pub(crate) fn do_spirit_healer_res(ctx: &ReducerContext, guid: u64) -> Result<()
     if player_level >= 11 {
         crate::spell::apply_spell_auras(ctx, RESURRECTION_SICKNESS_SPELL, guid, 1, 1);
     }
-    // This resolves the death outside of accepting a pending resurrect offer — drop any
-    // outstanding `game_resurrect_request` for this target so a stale offer doesn't resurface as a
-    // phantom SMSG_RESURRECT_REQUEST on a future reconnect. Idempotent (no-op if none pending).
-    ctx.db.game_resurrect_request().target_guid().delete(guid);
+    crate::spell::clear_resurrect_request_and_option(ctx, guid);
     Ok(())
 }
 
@@ -2200,13 +2192,8 @@ pub(crate) fn remove_live_character(ctx: &ReducerContext, entity: WorldEntity) {
         .guid()
         .delete(crate::corpse::corpse_guid_for(entity.guid));
 
-    // Leaving the world resolves the death outside of accepting a pending resurrect offer —
-    // drop any outstanding `game_resurrect_request` for this entity so a stale offer doesn't resurface
-    // as a phantom SMSG_RESURRECT_REQUEST on a future reconnect. Idempotent (no-op if none pending).
-    ctx.db
-        .game_resurrect_request()
-        .target_guid()
-        .delete(entity.guid);
+    // A Character that leaves the world comes back alive, so nothing may resurrect it later.
+    crate::spell::clear_resurrect_request_and_option(ctx, entity.guid);
 
     // Stealth drops on logout (vanilla): clear A_STEALTH so a stale aura doesn't survive the disconnect.
     // A_STEALTH is never timer-reaped, so otherwise the gateway's stealth create-skip would find the stale
diff --git a/module/tests/self_resurrection.rs b/module/tests/self_resurrection.rs
new file mode 100644
index 000000000..f237bc29c
--- /dev/null
+++ b/module/tests/self_resurrection.rs
@@ -0,0 +1,311 @@
+//! Self-Resurrection Option: chosen at death from a Soulstone aura, used through
+//! `debug_self_resurrect` (the `gw_self_resurrect` core), and spent by every other way back.
+
+mod support;
+
+use std::collections::BTreeMap;
+
+use lyracore_shared::constants::{player_flags, unit_flags, unit_vis_flags};
+use support::Standalone;
+
+type SqlRow = BTreeMap<String, String>;
+
+const PLAYER: u64 = 1;
+
+/// Minor Soulstone, from ClassicDB 1.12.1 `spell_template`: the aura rank and the spell it grants.
+const SOULSTONE_AURA: u32 = 20707;
+const SOULSTONE_SELF_RES: u32 = 3026;
+const SOULSTONE_HEALTH: u32 = 400;
+const SOULSTONE_MANA: u32 = 700;
+const RESURRECTION_SICKNESS: u32 = 15007;
+
+const E_SELF_RESURRECT: u32 = 0x26;
+const A_SELF_RESURRECT: u32 = 0xB5;
+const P_SPELL_ID: u32 = 15;
+const P_FLAT_MANA: u32 = 16;
+const T_SELF: u32 = 0;
+const T_TARGET_ALLY: u32 = 2;
+
+const WARRIOR: u32 = 1;
+const ROGUE: u32 = 4;
+const WARLOCK: u32 = 9;
+const MANA: u32 = 0;
+const RAGE: u32 = 1;
+const ENERGY: u32 = 3;
+
+#[test]
+#[ignore = "requires the SpacetimeDB 2.7.1 CLI and Wasm toolchain"]
+fn a_soulstone_death_holds_the_option_and_using_it_revives_in_place() {
+    let standalone = start("self-res-soulstone");
+    set_class(&standalone, WARLOCK, MANA, 2000);
+    soulstone(&standalone);
+
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+
+    assert_eq!(option_spell(&standalone), Some(SOULSTONE_SELF_RES));
+    assert!(
+        !has_aura(&standalone, SOULSTONE_AURA),
+        "the Soulstone aura does not survive death"
+    );
+
+    hold_vitals(&standalone);
+    standalone.assert_call("debug_self_resurrect", &[&PLAYER.to_string()]);
+
+    let player = entity(&standalone);
+    assert_alive_in_place(&player);
+    assert_eq!(number(&player, "health"), SOULSTONE_HEALTH);
+    assert_eq!(number(&player, "power"), SOULSTONE_MANA);
+    assert_eq!(
+        option_spell(&standalone),
+        None,
+        "using the option spends it"
+    );
+    assert!(
+        !has_aura(&standalone, RESURRECTION_SICKNESS),
+        "self-resurrection applies no Resurrection Sickness"
+    );
+}
+
+#[test]
+#[ignore = "requires the SpacetimeDB 2.7.1 CLI and Wasm toolchain"]
+fn without_an_option_self_resurrection_is_refused_and_changes_nothing() {
+    let standalone = start("self-res-refused");
+    soulstone(&standalone);
+    let alive = standalone.call("debug_self_resurrect", &[&PLAYER.to_string()]);
+    assert!(
+        !alive.status.success(),
+        "a living Character holds no option to use"
+    );
+
+    standalone.assert_sql(&format!(
+        "DELETE FROM game_aura WHERE target_guid = {PLAYER} AND spell_id = {SOULSTONE_AURA}"
+    ));
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    assert_eq!(option_spell(&standalone), None);
+
+    let dead = standalone.call("debug_self_resurrect", &[&PLAYER.to_string()]);
+    assert!(
+        !dead.status.success(),
+        "a death without a Soulstone gives no option"
+    );
+    let player = entity(&standalone);
+    assert_eq!(player["dead"], "true");
+    assert_eq!(number(&player, "health"), 0);
+}
+
+#[test]
+#[ignore = "requires the SpacetimeDB 2.7.1 CLI and Wasm toolchain"]
+fn the_option_survives_release_spirit_and_revives_the_ghost() {
+    let standalone = start("self-res-ghost");
+    set_class(&standalone, WARLOCK, MANA, 2000);
+    soulstone(&standalone);
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    standalone.assert_call("debug_repop", &[&PLAYER.to_string()]);
+
+    let ghost = entity(&standalone);
+    assert_ne!(number(&ghost, "player_flags") & player_flags::GHOST, 0);
+    assert_eq!(option_spell(&standalone), Some(SOULSTONE_SELF_RES));
+    assert_eq!(corpse_count(&standalone), 1);
+
+    hold_vitals(&standalone);
+    standalone.assert_call("debug_self_resurrect", &[&PLAYER.to_string()]);
+
+    let player = entity(&standalone);
+    assert_alive_in_place(&player);
+    assert_eq!(number(&player, "health"), SOULSTONE_HEALTH);
+    assert_eq!(corpse_count(&standalone), 0, "the corpse is gone");
+    assert_eq!(option_spell(&standalone), None);
+}
+
+#[test]
+#[ignore = "requires the SpacetimeDB 2.7.1 CLI and Wasm toolchain"]
+fn a_spirit_healer_resurrection_or_a_logout_spends_the_option() {
+    let standalone = start("self-res-other-paths");
+    soulstone(&standalone);
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    standalone.assert_call("debug_repop", &[&PLAYER.to_string()]);
+    standalone.assert_call("debug_spirit_healer_res", &[&PLAYER.to_string()]);
+    assert_eq!(
+        option_spell(&standalone),
+        None,
+        "a Spirit Healer res spends it"
+    );
+
+    soulstone(&standalone);
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    assert_eq!(option_spell(&standalone), Some(SOULSTONE_SELF_RES));
+    standalone.assert_call("claim_operator", &[]);
+    standalone.assert_call("debug_logout_character", &[&PLAYER.to_string()]);
+    assert_eq!(option_spell(&standalone), None, "a logout spends it");
+}
+
+#[test]
+#[ignore = "requires the SpacetimeDB 2.7.1 CLI and Wasm toolchain"]
+fn rage_comes_back_empty_and_energy_comes_back_full() {
+    let standalone = start("self-res-power-types");
+    set_class(&standalone, WARRIOR, RAGE, 1000);
+    standalone.assert_call("debug_set_power", &[&PLAYER.to_string(), "500"]);
+    soulstone(&standalone);
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    hold_vitals(&standalone);
+    standalone.assert_call("debug_self_resurrect", &[&PLAYER.to_string()]);
+    assert_eq!(number(&entity(&standalone), "power"), 0);
+
+    set_class(&standalone, ROGUE, ENERGY, 100);
+    standalone.assert_call("debug_set_power", &[&PLAYER.to_string(), "10"]);
+    soulstone(&standalone);
+    standalone.assert_call("debug_set_health", &[&PLAYER.to_string(), "0"]);
+    hold_vitals(&standalone);
+    standalone.assert_call("debug_self_resurrect", &[&PLAYER.to_string()]);
+    assert_eq!(number(&entity(&standalone), "power"), 100);
+}
+
+/// Publish, materialize the Character with room above the flat Soulstone health, and stage the
+/// Minor Soulstone spells. The aura has no cast time so the debug cast lands at once.
+fn start(name: &str) -> Standalone {
+    let mut standalone = Standalone::start(name);
+    standalone.publish_module();
+    standalone.assert_call("debug_spawn_player_entity", &[&PLAYER.to_string()]);
+    standalone.assert_sql(&format!(
+        "UPDATE game_world_entity SET max_health = 1000, health = 1000 WHERE guid = {PLAYER}"
+    ));
+    insert_spell(
+        &standalone,
+        SOULSTONE_AURA,
+        "Soulstone Resurrection",
+        1_800_000,
+    );
+    insert_effect(
+        &standalone,
+        SOULSTONE_AURA,
+        A_SELF_RESURRECT,
+        0,
+        T_TARGET_ALLY,
+        SOULSTONE_SELF_RES as i32,
+        P_SPELL_ID,
+    );
+    insert_spell(&standalone, SOULSTONE_SELF_RES, "Use Soulstone", 0);
+    insert_effect(
+        &standalone,
+        SOULSTONE_SELF_RES,
+        E_SELF_RESURRECT,
+        -(SOULSTONE_HEALTH as i32),
+        T_SELF,
+        SOULSTONE_MANA as i32,
+        P_FLAT_MANA,
+    );
+    standalone
+}
+
+fn soulstone(standalone: &Standalone) {
+    standalone.assert_call(
+        "debug_cast_at",
+        &[
+            &PLAYER.to_string(),
+            &SOULSTONE_AURA.to_string(),
+            &PLAYER.to_string(),
+        ],
+    );
+    assert!(has_aura(standalone, SOULSTONE_AURA));
+}
+
+/// Rewrite the class and power-type bytes of `unit_bytes_0` and the power pool.
+fn set_class(standalone: &Standalone, class: u32, power_type: u32, max_power: u32) {
+    let bytes = number(&entity(standalone), "unit_bytes_0");
+    let bytes = (bytes & 0x00FF_00FF) | (class << 8) | (power_type << 24);
+    standalone.assert_sql(&format!(
+        "UPDATE game_world_entity SET unit_bytes_0 = {bytes}, max_power = {max_power}, \
+         power = {max_power} WHERE guid = {PLAYER}"
+    ));
+}
+
+/// Keep scheduled regeneration and rage decay from moving an exact vitals observation: in combat
+/// until the end of time, and inside the mana regen pause.
+fn hold_vitals(standalone: &Standalone) {
+    let flags = number(&entity(standalone), "unit_flags");
+    standalone.assert_sql(&format!(
+        "UPDATE game_world_entity SET unit_flags = {}, combat_until_ms = {}, \
+         mana_regen_paused_until_ms = {} WHERE guid = {PLAYER}",
+        flags | unit_flags::IN_COMBAT,
+        u64::MAX,
+        u64::MAX,
+    ));
+}
+
+fn assert_alive_in_place(player: &SqlRow) {
+    assert_eq!(player["dead"], "false");
+    assert_eq!(number(player, "player_flags") & player_flags::GHOST, 0);
+    assert_eq!(number(player, "unit_bytes_1") & unit_vis_flags::GHOST, 0);
+}
+
+fn insert_spell(standalone: &Standalone, spell_id: u32, name: &str, duration_ms: u32) {
+    standalone.assert_sql(&format!(
+        "INSERT INTO game_spell (spell_id, name, power_type, cost, cast_time_ms, gcd_ms, \
+         cooldown_ms, range_yd, duration_ms, school_mask, dispel_type, mechanic, max_stacks, \
+         aura_interrupt, attributes, spell_level, max_level, is_negative, cast_flags, stances, \
+         family_name, family_flags, proc_flags, proc_chance, proc_charges) \
+         VALUES ({spell_id}, '{name}', 0, 0, 0, 0, 0, 0, {duration_ms}, 32, 0, 0, 0, 0, 0, 0, 0, \
+         false, 0, 0, 0, 0, 0, 0, 0)"
+    ));
+}
+
+/// One effect row at index 0. The self-resurrect row keeps vanilla's one-sided die, which the rule
+/// must ignore.
+fn insert_effect(
+    standalone: &Standalone,
+    spell_id: u32,
+    kind: u32,
+    base_points: i32,
+    target: u32,
+    p0: i32,
+    p0_kind: u32,
+) {
+    let id = (spell_id as u64) << 2;
+    standalone.assert_sql(&format!(
+        "INSERT INTO game_spell_effect (id, spell_id, effect_index, kind, base_points, die_sides, \
+         per_level, period_ms, target, radius_yd, chain_targets, trigger_spell, effect_mechanic, \
+         p0, p0_kind, p1, script_id, enters_combat) \
+         VALUES ({id}, {spell_id}, 0, {kind}, {base_points}, 1, 0.0, 0, {target}, \
+         0.0, 0, 0, 0, {p0}, {p0_kind}, 0, 0, false)"
+    ));
+}
+
+fn entity(standalone: &Standalone) -> SqlRow {
+    standalone
+        .query_rows(&format!(
+            "SELECT * FROM game_world_entity WHERE guid = {PLAYER}"
+        ))
+        .pop()
+        .expect("the Character must be live")
+}
+
+fn number(row: &SqlRow, column: &str) -> u32 {
+    row[column]
+        .parse()
+        .unwrap_or_else(|_| panic!("{column} is a number: {}", row[column]))
+}
+
+fn option_spell(standalone: &Standalone) -> Option<u32> {
+    standalone
+        .query_rows(&format!(
+            "SELECT spell_id FROM game_self_resurrect_option WHERE character_guid = {PLAYER}"
+        ))
+        .pop()
+        .map(|row| number(&row, "spell_id"))
+}
+
+fn has_aura(standalone: &Standalone, spell_id: u32) -> bool {
+    !standalone
+        .query_rows(&format!(
+            "SELECT id FROM game_aura WHERE target_guid = {PLAYER} AND spell_id = {spell_id}"
+        ))
+        .is_empty()
+}
+
+fn corpse_count(standalone: &Standalone) -> usize {
+    standalone
+        .query_rows(&format!(
+            "SELECT guid FROM game_corpse WHERE owner_guid = {PLAYER}"
+        ))
+        .len()
+}