From 9cdeabc77de864c31a4aebbbefefa31c1ef9f54a Mon Sep 17 00:00:00 2001
From: Mathias Hartveit <mathias.hartveit@tetdigital.no>
Date: Mon, 5 Oct 2026 20:29:25 +0200
Subject: [PATCH 1/3] feat(spells): a Soulstone gives a dead Character a
 Self-Resurrection Option

A Character that dies with a Soulstone aura now holds a Self-Resurrection
Option in the new game_self_resurrect_option table. The death hook reads it
before the death aura shed. gw_self_resurrect and debug_self_resurrect use
it: the Character revives in place at the option spell's vitals, without
Resurrection Sickness, and the corpse goes. Release Spirit keeps the option.
Every other revive and leaving the world delete it.

The importer maps raw effect 94 to E_SELF_RESURRECT and the five Soulstone
Resurrection aura ranks to A_SELF_RESURRECT with their option spell ids.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CONTEXT.md                                    |  12 +
 .../bindings/debug_self_resurrect_reducer.rs  |  68 ++++
 .../game_self_resurrect_option_table.rs       | 231 +++++++++++++
 .../bindings/gw_self_resurrect_reducer.rs     |  70 ++++
 gateway/src/stdb/bindings/mod.rs              |  52 ++-
 .../bindings/self_resurrect_option_type.rs    |  52 +++
 importer/src/spell.rs                         | 131 +++++++-
 module/src/actor.rs                           |   2 +
 module/src/combat/death.rs                    |   4 +-
 module/src/corpse.rs                          |   9 +-
 module/src/debug/mod.rs                       |   7 +
 module/src/gw.rs                              |  12 +
 module/src/spell/cast/targeting.rs            |   8 +
 module/src/spell/mod.rs                       |   3 +
 module/src/spell/scheduler.rs                 |   1 +
 module/src/spell/self_resurrect.rs            | 169 ++++++++++
 module/src/spell/tables.rs                    |  11 +
 module/src/spell/taxonomy.rs                  |  18 +-
 module/src/spell/tests.rs                     |  10 +-
 module/src/tripwires.rs                       |   1 +
 module/src/world.rs                           |  25 +-
 module/tests/self_resurrection.rs             | 311 ++++++++++++++++++
 22 files changed, 1173 insertions(+), 34 deletions(-)
 create mode 100644 gateway/src/stdb/bindings/debug_self_resurrect_reducer.rs
 create mode 100644 gateway/src/stdb/bindings/game_self_resurrect_option_table.rs
 create mode 100644 gateway/src/stdb/bindings/gw_self_resurrect_reducer.rs
 create mode 100644 gateway/src/stdb/bindings/self_resurrect_option_type.rs
 create mode 100644 module/src/spell/self_resurrect.rs
 create mode 100644 module/tests/self_resurrection.rs

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/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/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()
+}

From 29cacffc2841932fc85be42f27418781d85f4263 Mon Sep 17 00:00:00 2001
From: Mathias Hartveit <mathias.hartveit@tetdigital.no>
Date: Mon, 5 Oct 2026 20:29:25 +0200
Subject: [PATCH 2/3] feat(gateway): relay the Self-Resurrection Option and
 handle CMSG_SELF_RES

The Gateway writes the option into the owner's PLAYER_SELF_RES_SPELL through
the partial-VALUES path, and clears it when the row goes. CMSG_SELF_RES calls
gw_self_resurrect for the session's own Character.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 gateway/src/codec/tests.rs         | 27 +++++++++
 gateway/src/codec/values.rs        |  9 +++
 gateway/src/stdb/connection.rs     |  1 +
 gateway/src/stdb/reducers.rs       | 14 +++++
 gateway/src/stdb/subscriptions.rs  |  9 +++
 gateway/src/stdb/world_store.rs    |  4 ++
 gateway/src/stdb/world_view.rs     | 90 ++++++++++++++++++++++++++++--
 gateway/src/world/handlers/loot.rs | 15 +++++
 gateway/src/world/store.rs         |  5 ++
 gateway/src/world/tests.rs         | 50 ++++++++++++++++-
 gateway/tests/schema_parity.rs     |  4 ++
 11 files changed, 223 insertions(+), 5 deletions(-)

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/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",

From ad6b5a8b6c78fe7abf1a1cd6c5fdf3d7ac7eaa21 Mon Sep 17 00:00:00 2001
From: Mathias Hartveit <mathias.hartveit@tetdigital.no>
Date: Mon, 5 Oct 2026 20:29:25 +0200
Subject: [PATCH 3/3] docs(spells): add the self-resurrection client check

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/architecture.md                   |  1 +
 docs/self-resurrection-client-check.md | 47 ++++++++++++++++++++++++++
 2 files changed, 48 insertions(+)
 create mode 100644 docs/self-resurrection-client-check.md

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.