fix(engine): fuse battlefield-entry record+emit into one authority

crates/engine/src/game/effects/conjure.rs

@@ -186,9 +186,7 @@ pub fn resolve(
                     }
                 }
 
-                // Record battlefield entry for restriction tracking.
                 if destination == Zone::Battlefield {
-                    crate::game::restrictions::record_battlefield_entry(state, obj_id);
                     // Battlefield entry: incremental re-derive candidate for this
                     // conjured object (escalates to Full if it sources effects/etc.).
                     crate::game::layers::mark_layers_entered(state, obj_id);
@@ -202,20 +200,22 @@ pub fn resolve(
                     // (e.g. Verdant Dread's "another Verdant Dread enters" manifest-dread
                     // trigger, Soul Warden, Panharmonicon). Without this the conjured
                     // permanent enters silently and no ETB ability ever triggers.
-                    let zone_change_record = state
-                        .objects
-                        .get(&obj_id)
-                        .expect("conjured object was just created")
-                        .snapshot_for_zone_change(obj_id, None, Zone::Battlefield);
-                    state
-                        .zone_changes_this_turn
-                        .push_back(zone_change_record.clone());
-                    events.push(GameEvent::ZoneChanged {
-                        object_id: obj_id,
-                        from: None,
-                        to: Zone::Battlefield,
-                        record: Box::new(zone_change_record),
-                    });
+                    //
+                    // Conjuring is an Alchemy/Arena digital-only mechanic with NO
+                    // Comprehensive Rules entry — the string "conjure" does not occur in the
+                    // CR. The rules cited here are the ones the operation borrows: CR 400.7
+                    // (the zone change), CR 608.2i (the battlefield-entry bookkeeping),
+                    // CR 603.2c + CR 603.6a (why the index is load-bearing for batched ETB
+                    // triggers).
+                    //
+                    // CR 400.7 + CR 608.2i + CR 603.2c: route the record and the emit through
+                    // the single `from: None → Battlefield` authority so the emitted record
+                    // carries this turn's real zone-change index instead of the `0`
+                    // placeholder, and so the CR 608.2i battlefield-entry row is written
+                    // exactly once (the authority calls `record_battlefield_entry` itself —
+                    // a co-located second call here would double-count it).
+                    crate::game::zones::record_and_emit_entry_from_no_zone(state, obj_id, events)
+                        .expect("conjured object was just created");
                 }
 
                 events.push(GameEvent::ObjectConjured {

crates/engine/src/game/effects/gift_delivery.rs

@@ -154,29 +154,25 @@ fn create_gift_token(
     }
 
     crate::game::layers::mark_layers_full(state);
-    crate::game::restrictions::record_battlefield_entry(state, obj_id);
     crate::game::restrictions::record_token_created(state, obj_id);
 
     // CR 111.1 + CR 603.6a: Token creation is a zone change from outside the
     // game — emit `ZoneChanged { from: None }` so ETB triggers (Soul Warden,
     // Panharmonicon, etc.) fire for gift tokens through the normal code path.
-    let zone_change_record = state
-        .objects
-        .get(&obj_id)
-        .expect("token just created")
-        .snapshot_for_zone_change(obj_id, None, Zone::Battlefield);
-    events.push(GameEvent::ZoneChanged {
-        object_id: obj_id,
-        from: None,
-        to: Zone::Battlefield,
-        record: Box::new(zone_change_record),
-    });
-
-    events.push(GameEvent::TokenCreated {
-        object_id: obj_id,
-        name: name.to_string(),
+    //
+    // CR 400.7 + CR 608.2i + CR 603.2c: route the record and the entry pair through the single
+    // `from: None → Battlefield` authority so the emitted `ZoneChanged` carries this turn's real
+    // zone-change index instead of the `0` placeholder. The authority performs the CR 608.2i
+    // battlefield-entry bookkeeping itself, so the co-located `record_battlefield_entry` call is
+    // deleted — keeping it would double-count `battlefield_entries_this_turn`.
+    super::token::push_committed_token_entry_events(
+        state,
+        obj_id,
+        name.to_string(),
         source_id,
-    });
+        events,
+    )
+    .expect("token just created");
 
     obj_id
 }

crates/engine/src/game/effects/incubate.rs

@@ -96,7 +96,7 @@ pub fn resolve(
     // token (escalates to a full pass if it sources effects, carries
     // counters, etc.).
     crate::game::layers::mark_layers_entered(state, obj_id);
-    // CR 403.3 battlefield-entry bookkeeping is done by `record_zone_change` below —
+    // CR 608.2i battlefield-entry bookkeeping is done by `record_zone_change` below —
     // recording it here too would double-count `battlefield_entries_this_turn`.
     crate::game::restrictions::record_token_created(state, obj_id);
 
@@ -111,26 +111,21 @@ pub fn resolve(
     // `token.rs::apply_create_token_after_replacement_with_created_ids` and
     // `conjure.rs`'s identical fix for the same bug class.
     //
-    // CR 400.7 + CR 603.2c: route the record through `restrictions::record_zone_change` — the
-    // single authority that assigns this turn's zone-change index — and write the assigned index
-    // back onto the emitted record. `snapshot_for_zone_change` leaves it at its `0` placeholder,
-    // and the batched zone-change replay guard (`triggers.rs`) dedups on
-    // `(definition_ref, turn_zone_change_index)` read off the EVENT, so an unrouted record aliases
-    // this Incubator onto occurrence `0` and a `batched: true` ETB trigger that already fired for
-    // another entry this turn is swallowed. Same shape as `merge.rs` and `token.rs`.
-    let mut zone_change_record = state
-        .objects
-        .get(&obj_id)
-        .expect("incubator token was just created")
-        .snapshot_for_zone_change(obj_id, None, Zone::Battlefield);
-    zone_change_record.turn_zone_change_index =
-        crate::game::restrictions::record_zone_change(state, zone_change_record.clone());
-    events.push(GameEvent::ZoneChanged {
-        object_id: obj_id,
-        from: None,
-        to: Zone::Battlefield,
-        record: Box::new(zone_change_record),
-    });
+    // CR 400.7 + CR 608.2i + CR 603.2c: route the record and the emit through
+    // `zones::record_and_emit_entry_from_no_zone` — the single `from: None → Battlefield`
+    // authority, which assigns this turn's zone-change index through
+    // `restrictions::record_zone_change` and writes it back onto the record it emits.
+    // That one call writes BOTH ledgers, which is why both rules are cited here: the CR 400.7
+    // zone-change row (whose length IS the index allocator) and — because `to_zone` is
+    // `Battlefield` — the CR 608.2i battlefield-entry row, via `record_battlefield_entry`. The
+    // latter is the look-back journal that a permanent which has since left still counts in, so
+    // re-recording either ledger at this call site would double-count it.
+    // `snapshot_for_zone_change` leaves that index at its `0` placeholder, and the batched
+    // zone-change replay guard (`triggers.rs`) dedups on `(definition_ref, turn_zone_change_index)`
+    // read off the EVENT, so an unrouted record aliases this Incubator onto occurrence `0` and a
+    // `batched: true` ETB trigger that already fired for another entry this turn is swallowed.
+    crate::game::zones::record_and_emit_entry_from_no_zone(state, obj_id, events)
+        .expect("incubator token was just created");
 
     super::token::inject_predefined_token_abilities(state, obj_id);