rn-gamekit 0.1.0 → 0.2.1

package/lib/module/core/session/createGameSession.js

@@ -4,7 +4,47 @@ import { createAnimationFrameDriver } from "../frameDriver.js";
 import { createInputBuffer } from "../input/createInputBuffer.js";
 import { GameSessionDisposedError, GameSessionLifecycleError } from "./types.js";
 import { createDeepFreeze } from "./deepFreeze.js";
+import { GameEventError } from "../../events/errors.js";
+import { cloneAndValidatePayload } from "../../events/payload.js";
 const DEFAULT_FIXED_STEP_MS = 1000 / 60;
+
+/**
+ * A captured failure: an explicit boolean record so an arbitrary thrown
+ * value (including `undefined`) is never confused with "no failure".
+ */
+
+const NO_FAILURE = {
+  failed: false
+};
+
+/** Run a closure and capture its thrown value, whatever its type. */
+function captureFailure(run) {
+  try {
+    run();
+    return NO_FAILURE;
+  } catch (error) {
+    return {
+      failed: true,
+      value: error
+    };
+  }
+}
+
+/** Surface a captured failure, throwing `undefined` if that was the value. */
+function throwFailure(record) {
+  if (record.failed) {
+    throw record.value;
+  }
+}
+
+/**
+ * Immutably compose two failures into one lossless error: an AggregateError
+ * with a stable message and ordered `errors`. Neither thrown value is
+ * mutated or wrapped away.
+ */
+function composeFailures(first, second) {
+  return new AggregateError([first, second], 'Lifecycle operation failed with multiple errors');
+}
 const DEFAULT_MAX_CATCH_UP_STEPS = 5;
 function now() {
   return typeof performance !== 'undefined' ? performance.now() : 0;
@@ -47,6 +87,34 @@ export function createGameSessionWithDriver(definition, options) {
   if (!(maxFrameDeltaMs > 0) || !Number.isFinite(maxFrameDeltaMs)) {
     throw new RangeError('maxFrameDeltaMs must be a finite positive number');
   }
+
+  // T13: event definitions and per-scene emit declarations.
+  const eventDefs = definition.events;
+  const hasEvents = eventDefs !== undefined && eventDefs !== null;
+  const allowedEventNames = hasEvents ? new Set(Object.keys(eventDefs)) : new Set();
+  const allowedEmitsByScene = new Map();
+  // Validate per-scene emits are declared events and that the scene's `events` reference matches the game's.
+  for (const [name, scene] of Object.entries(definition.scenes)) {
+    const erased = scene;
+    const emits = erased.emits ?? [];
+    for (const ev of emits) {
+      if (!allowedEventNames.has(ev)) {
+        throw new Error(`Scene "${name}" declares unknown event "${ev}"`);
+      }
+    }
+    allowedEmitsByScene.set(name, new Set(emits));
+    // Runtime identity check for the branded event definitions.
+    if (erased.events !== undefined) {
+      if (!hasEvents) {
+        throw new Error(`Scene "${name}" is bound to events but the game has no events map`);
+      }
+      if (erased.events !== eventDefs) {
+        throw new Error(`Scene "${name}" is bound to a different events object than the game. Pass the same defineGameEvents() result to both defineScene({ events }) and defineGame({ events }).`);
+      }
+    } else if (emits.length > 0) {
+      throw new Error(`Scene "${name}" declares emits but is not bound to the game's events. Pass \`events\` to defineScene.`);
+    }
+  }
   const erasedSceneMap = {};
   for (const [name, scene] of Object.entries(definition.scenes)) {
     const erased = scene;
@@ -74,16 +142,24 @@ export function createGameSessionWithDriver(definition, options) {
   try {
     initialSnapshot = deepFreeze(initialDefinition.snapshot({
       state: initialState
-    }));
+    }), {
+      scene: initialSceneName
+    });
   } catch (error) {
-    initialDefinition.dispose?.(initialState);
+    // GS-SCENE-02: the cleanup failure must not replace the snapshot
+    // failure — compose losslessly in a stable order instead.
+    const cleanupFailure = captureFailure(() => initialDefinition.dispose?.(initialState));
+    if (cleanupFailure.failed) {
+      throw composeFailures(error, cleanupFailure.value);
+    }
     throw error;
   }
   let activeScene = {
     name: initialSceneName,
     definition: initialDefinition,
     state: initialState,
-    sceneTick: 0
+    sceneTick: 0,
+    disposalAttempted: false
   };
   let sceneName = initialSceneName;
   let currentSnapshot = initialSnapshot;
@@ -95,6 +171,12 @@ export function createGameSessionWithDriver(definition, options) {
   let accumulatorMs = 0;
   let tick = 0;
   let pendingTransition;
+  /**
+   * Set when an outgoing scene disposal throws: the retained scene is
+   * explicitly non-resumable — `start()` refuses to update it until a
+   * transition or restart replaces it. Cleared on every successful install.
+   */
+  let sceneFaulted = false;
   let hardCutPending = false;
   let publishedThisCallback = false;
   let updateInProgress = false;
@@ -110,13 +192,138 @@ export function createGameSessionWithDriver(definition, options) {
     stepMs: fixedStepMs
   });
   const listeners = new Set();
+  const statusListeners = new Set();
+  let deliveringStatus = false;
+  const queuedStatuses = [];
+  let releaseStatusListeners = false;
+
+  // T13: per-session event listeners.
+  const eventListeners = new Map();
+
+  // Centralized, non-recursive error sink for game event listeners.
+  // A failing reporter must not pause the session or escape into the fixed-step loop.
+  const reportGameEventListenerError = (name, error) => {
+    try {
+      console.error(`Game event listener for "${name}" threw:`, error);
+    } catch {
+      // Swallow reporter failures — the session must remain running and siblings must still run.
+    }
+  };
+  const deliverEvents = envelopes => {
+    // Snapshot per tick: a listener added during this tick's delivery receives
+    // only later ticks, and a removal prevents only future ticks.
+    const snapshots = new Map();
+    for (const env of envelopes) {
+      if (!snapshots.has(env.name)) {
+        const set = eventListeners.get(env.name);
+        snapshots.set(env.name, set ? [...set] : []);
+      }
+    }
+    for (const envelope of envelopes) {
+      const snapshot = snapshots.get(envelope.name) ?? [];
+      for (const listener of snapshot) {
+        let result;
+        try {
+          result = listener(envelope);
+        } catch (error) {
+          reportGameEventListenerError(envelope.name, error);
+          continue;
+        }
+        if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+          result.catch(error => {
+            reportGameEventListenerError(envelope.name, error);
+          });
+        }
+      }
+    }
+  };
+  const NO_EVENT_EMITTER = Object.freeze({
+    emit() {
+      throw new GameEventError('This game has no events or this scene does not emit any events');
+    }
+  });
+
+  // Deliver one transition pass to a snapshot. A throwing listener never
+  // aborts the pass: the remaining snapshot listeners still run, and the
+  // first failure is rethrown once every queued transition has been
+  // delivered (the transition itself is already authoritative).
+  const deliverStatusPass = current => {
+    let firstFailure = NO_FAILURE;
+    for (const listener of [...statusListeners]) {
+      try {
+        listener(current);
+      } catch (error) {
+        if (!firstFailure.failed) {
+          firstFailure = {
+            failed: true,
+            value: error
+          };
+        }
+      }
+    }
+    return firstFailure;
+  };
+  const notifyStatus = () => {
+    if (deliveringStatus) {
+      // Re-entrant transition from inside a listener: queue it so every
+      // listener observes complete states, never a half-applied transition.
+      queuedStatuses.push(status);
+      return;
+    }
+    deliveringStatus = true;
+    let firstFailure = NO_FAILURE;
+    try {
+      const passFailure = deliverStatusPass(status);
+      if (!firstFailure.failed) {
+        firstFailure = passFailure;
+      }
+      while (queuedStatuses.length > 0) {
+        const queued = queuedStatuses.shift();
+        const queuedFailure = deliverStatusPass(queued);
+        if (!firstFailure.failed) {
+          firstFailure = queuedFailure;
+        }
+      }
+    } finally {
+      deliveringStatus = false;
+      if (releaseStatusListeners) {
+        releaseStatusListeners = false;
+        statusListeners.clear();
+        diagnostics?.onStatusListenerCount?.(statusListeners.size);
+      }
+    }
+    throwFailure(firstFailure);
+  };
+
+  // Status becomes authoritative only after the command's scheduling and
+  // input side effects are safe; listeners then observe the committed value.
+  const setStatus = next => {
+    if (status === next) {
+      return;
+    }
+    status = next;
+    notifyStatus();
+  };
+
+  // Error-path pause: complete the transition and notify, but never let a
+  // status-listener failure mask the original error that caused the pause.
+  const pauseAndRethrow = original => {
+    try {
+      pauseInternal();
+    } catch {
+      // The original error is the actionable one; listeners were notified.
+    }
+    throw original;
+  };
   const assertLive = () => {
     if (status === 'disposed') {
       throw new GameSessionDisposedError();
     }
   };
   const isDisposed = () => status === 'disposed';
-  const inputBuffer = createInputBuffer(definition.input, assertLive);
+  // T10.4: gameplay input is rejected at the shared boundary while paused
+  // (before the queue and before the accepted-input diagnostics).
+  const inputBuffer = createInputBuffer(definition.input, assertLive, () => status === 'paused');
 
   // Simulation commits are the only presentation updates (T5): a commit
   // happens on the initial baseline, after every presentation callback that
@@ -152,7 +359,6 @@ export function createGameSessionWithDriver(definition, options) {
     if (status !== 'running') {
       return;
     }
-    status = 'paused';
     generation += 1;
     if (frameHandle !== undefined) {
       options.frameDriver.cancelFrame(frameHandle);
@@ -161,16 +367,29 @@ export function createGameSessionWithDriver(definition, options) {
     previousTimestampMs = undefined;
     accumulatorMs = 0;
     inputBuffer.reset();
+    setStatus('paused');
   };
   const commitOrPause = () => {
     try {
       commit();
     } catch (error) {
-      pauseInternal();
-      throw error;
+      pauseAndRethrow(error);
     }
   };
 
+  /**
+   * Dispose one scene instance exactly once. The attempt flag is set before
+   * user cleanup runs, so a throwing disposer is never retried for this
+   * instance — by transition retries or by session disposal.
+   */
+  const disposeSceneInstance = (scene, state) => {
+    if (scene.disposalAttempted) {
+      return;
+    }
+    scene.disposalAttempted = true;
+    scene.definition.dispose?.(state);
+  };
+
   /**
    * Transition to `targetName` following the deterministic ordering:
    * prepare the target -> dispose the outgoing scene exactly once -> advance
@@ -198,7 +417,9 @@ export function createGameSessionWithDriver(definition, options) {
       targetCreated = true;
       targetSnapshot = deepFreeze(targetDefinition.snapshot({
         state: targetState
-      }));
+      }), {
+        scene: targetName
+      });
     } catch (error) {
       if (targetCreated) {
         try {
@@ -210,15 +431,17 @@ export function createGameSessionWithDriver(definition, options) {
       throw error;
     }
     try {
-      activeScene.definition.dispose?.(outgoingFinalState);
+      disposeSceneInstance(activeScene, outgoingFinalState);
     } catch (error) {
-      // The outgoing scene's dispose already ran (possibly partially) and is
-      // not retried; the old scene remains active with that honest caveat.
+      // The outgoing scene's dispose already ran (possibly partially) and
+      // is never retried; the old scene remains active but explicitly
+      // faulted. The prepared target is still cleaned up, and a failing
+      // target cleanup composes losslessly with the outgoing failure.
+      sceneFaulted = true;
       if (targetCreated) {
-        try {
-          targetDefinition.dispose?.(targetState);
-        } catch {
-          // Best effort.
+        const targetFailure = captureFailure(() => targetDefinition.dispose?.(targetState));
+        if (targetFailure.failed) {
+          throw composeFailures(error, targetFailure.value);
         }
       }
       throw error;
@@ -230,8 +453,10 @@ export function createGameSessionWithDriver(definition, options) {
       name: targetName,
       definition: targetDefinition,
       state: targetState,
-      sceneTick: 0
+      sceneTick: 0,
+      disposalAttempted: false
     };
+    sceneFaulted = false;
     sceneName = targetName;
     currentSnapshot = targetSnapshot;
     previousSnapshot = targetSnapshot;
@@ -290,6 +515,30 @@ export function createGameSessionWithDriver(definition, options) {
       }
     });
   };
+
+  // One scheduler-failure policy for successor scheduling (GS-SESSION-02).
+  // The initial `start()` path keeps its own restore-previous-status policy
+  // because no running state was ever published there. On failure: clear the
+  // handle, invalidate the generation so late callbacks are no-ops,
+  // neutralize input via the pause path, and publish paused while preserving
+  // the scheduling error — a throwing status listener composes with it
+  // instead of masking it. Never retries automatically.
+  const failScheduling = error => {
+    frameHandle = undefined;
+    try {
+      pauseInternal();
+    } catch (statusError) {
+      throw composeFailures(error, statusError);
+    }
+    throw error;
+  };
+  const scheduleSuccessor = activeGeneration => {
+    try {
+      schedule(activeGeneration);
+    } catch (error) {
+      failScheduling(error);
+    }
+  };
   const schedule = activeGeneration => {
     frameHandle = options.frameDriver.requestFrame(timestampMs => {
       if (status !== 'running' || generation !== activeGeneration) {
@@ -301,16 +550,17 @@ export function createGameSessionWithDriver(definition, options) {
         diagnostics.onDisplayCallback();
       }
 
-      // A pending external transition commits at the next fixed-step boundary
-      // without advancing simulation tick/time.
+      // A pending external transition commits at the next frame-driver
+      // callback — a zero-step callback may carry it — without advancing
+      // simulation tick/time. The target scene first updates at the next
+      // due fixed step; accumulated timing debt is preserved.
       if (pendingTransition !== undefined) {
         const pending = pendingTransition;
         pendingTransition = undefined;
         try {
           commitTransition(pending, activeScene.state, undefined);
         } catch (error) {
-          pauseInternal();
-          throw error;
+          pauseAndRethrow(error);
         }
         commitOrPause();
         if (status !== 'running' || generation !== activeGeneration) {
@@ -323,7 +573,7 @@ export function createGameSessionWithDriver(definition, options) {
           commitOrPause();
         }
         if (status === 'running' && generation === activeGeneration) {
-          schedule(activeGeneration);
+          scheduleSuccessor(activeGeneration);
         }
         return;
       }
@@ -338,6 +588,39 @@ export function createGameSessionWithDriver(definition, options) {
           stepsRan = true;
           const nextTick = tick + 1;
           const nextSceneTick = activeScene.sceneTick + 1;
+          const sceneNameForTick = activeScene.name;
+          const allowedEmits = allowedEmitsByScene.get(sceneNameForTick) ?? new Set();
+
+          // T13: per-tick transactional emitter.
+          let stagedThisTick = [];
+          let ordinal = 0;
+          let emitterInvalidated = false;
+          const emitter = hasEvents ? {
+            emit(name, payload) {
+              if (emitterInvalidated) {
+                throw new GameEventError('Game event emitter is only valid during its owning scene update');
+              }
+              if (!allowedEventNames.has(name)) {
+                throw new GameEventError(`Event "${name}" is not declared by this game`);
+              }
+              if (!allowedEmits.has(name)) {
+                throw new GameEventError(`Scene "${sceneNameForTick}" cannot emit event "${name}" (missing from its emits list)`);
+              }
+              const cloned = cloneAndValidatePayload(payload, name, 'payload');
+              const envelope = Object.freeze({
+                name,
+                payload: cloned,
+                tick: nextTick,
+                scene: sceneNameForTick,
+                sceneTick: nextSceneTick,
+                ordinal: ordinal++
+              });
+              stagedThisTick.push(envelope);
+            }
+          } : NO_EVENT_EMITTER;
+          if (hasEvents) {
+            Object.freeze(emitter);
+          }
           const sampleStart = diagnostics === undefined ? 0 : now();
           const input = inputBuffer.sample();
           if (diagnostics !== undefined) {
@@ -347,16 +630,30 @@ export function createGameSessionWithDriver(definition, options) {
           activeUpdateScope = scope;
           updateInProgress = true;
           const updateStart = diagnostics === undefined ? 0 : now();
-          const nextState = freezeObject(activeScene.definition.update({
-            state: activeScene.state,
-            input,
-            transition: makeTransitionController(scope),
-            tick: nextTick,
-            sceneTick: nextSceneTick,
-            deltaSeconds: fixedStepMs / 1000,
-            elapsedSeconds: nextTick * fixedStepMs / 1000,
-            sceneElapsedSeconds: nextSceneTick * fixedStepMs / 1000
-          }));
+          let nextState;
+          try {
+            nextState = freezeObject(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            activeScene.definition.update({
+              state: activeScene.state,
+              input,
+              transition: makeTransitionController(scope),
+              events: emitter,
+              tick: nextTick,
+              sceneTick: nextSceneTick,
+              deltaSeconds: fixedStepMs / 1000,
+              elapsedSeconds: nextTick * fixedStepMs / 1000,
+              sceneElapsedSeconds: nextSceneTick * fixedStepMs / 1000
+            }));
+          } catch (error) {
+            // Update failed: discard staged events, invalidate emitter.
+            stagedThisTick = [];
+            emitterInvalidated = true;
+            activeUpdateScope = undefined;
+            updateInProgress = false;
+            throw error;
+          }
+          emitterInvalidated = true;
           activeUpdateScope = undefined;
           updateInProgress = false;
           if (diagnostics !== undefined) {
@@ -370,7 +667,17 @@ export function createGameSessionWithDriver(definition, options) {
             // A transition requested during update commits after this update
             // completes successfully. The update consumed one fixed step; the
             // hard-cut frame publishes at the end of this presentation callback.
-            commitTransition(intent, nextState, nextTick, true);
+            try {
+              commitTransition(intent, nextState, nextTick, true);
+            } catch (error) {
+              // Transition preparation/disposal failed: discard staged events.
+              stagedThisTick = [];
+              throw error;
+            }
+            // Successful transition tick: staged events commit with source tick/scene.
+            if (stagedThisTick.length > 0) {
+              deliverEvents(stagedThisTick);
+            }
             accumulatorMs = Math.max(0, accumulatorMs - fixedStepMs);
             // F4: the transition consumed one fixed step; report it as such
             // and never as a zero-step callback (zero-step fires only when
@@ -381,14 +688,29 @@ export function createGameSessionWithDriver(definition, options) {
             break;
           }
           const snapshotStart = diagnostics === undefined ? 0 : now();
-          const rawSnapshot = activeScene.definition.snapshot({
-            state: nextState
-          });
+          let rawSnapshot;
+          try {
+            rawSnapshot = activeScene.definition.snapshot({
+              state: nextState
+            });
+          } catch (error) {
+            stagedThisTick = [];
+            throw error;
+          }
           if (diagnostics !== undefined) {
             diagnostics.onSnapshot(now() - snapshotStart);
           }
           const freezeStart = diagnostics === undefined ? 0 : now();
-          const nextSnapshot = deepFreeze(rawSnapshot);
+          let nextSnapshot;
+          try {
+            nextSnapshot = deepFreeze(rawSnapshot, {
+              scene: sceneNameForTick,
+              tick: nextTick
+            });
+          } catch (error) {
+            stagedThisTick = [];
+            throw error;
+          }
           if (diagnostics !== undefined) {
             diagnostics.onDeepFreeze(now() - freezeStart);
           }
@@ -400,6 +722,10 @@ export function createGameSessionWithDriver(definition, options) {
           previousSnapshot = currentSnapshot;
           currentSnapshot = nextSnapshot;
           tick = nextTick;
+          // Successful tick: deliver staged events in tick order, then emission order.
+          if (stagedThisTick.length > 0) {
+            deliverEvents(stagedThisTick);
+          }
           accumulatorMs = Math.max(0, accumulatorMs - fixedStepMs);
           catchUpSteps += 1;
           if (diagnostics !== undefined) {
@@ -412,8 +738,7 @@ export function createGameSessionWithDriver(definition, options) {
       } catch (error) {
         activeUpdateScope = undefined;
         updateInProgress = false;
-        pauseInternal();
-        throw error;
+        pauseAndRethrow(error);
       }
       if (catchUpSteps === maxCatchUpSteps && accumulatorMs >= fixedStepMs) {
         const droppedSteps = Math.floor(accumulatorMs / fixedStepMs);
@@ -435,7 +760,7 @@ export function createGameSessionWithDriver(definition, options) {
         commitOrPause();
       }
       if (status === 'running' && generation === activeGeneration) {
-        schedule(activeGeneration);
+        scheduleSuccessor(activeGeneration);
       }
     });
   };
@@ -453,21 +778,41 @@ export function createGameSessionWithDriver(definition, options) {
       if (status === 'running') {
         return;
       }
-      status = 'running';
+      if (sceneFaulted) {
+        throw new GameSessionLifecycleError('The active scene failed disposal and is explicitly non-resumable: ' + 'replace it with setScene() or restartScene() before start(), or dispose the session.');
+      }
+      const previous = status;
       previousTimestampMs = undefined;
       accumulatorMs = 0;
       const activeGeneration = ++generation;
-      schedule(activeGeneration);
+      try {
+        schedule(activeGeneration);
+      } catch (error) {
+        // Do not publish `running` when scheduling could not be established.
+        status = previous;
+        throw error;
+      }
+      setStatus('running');
     },
     pause() {
       assertLive();
-      pauseInternal();
-      if (pendingTransition !== undefined) {
-        const pending = pendingTransition;
-        pendingTransition = undefined;
-        commitTransition(pending, activeScene.state, undefined);
-        commitOrPause();
+      const pauseFailure = captureFailure(() => pauseInternal());
+      // The command must complete: a pending external transition is resolved
+      // at the pause boundary even when a status listener threw, so a later
+      // start() can never commit a stale transition on an unexpected frame.
+      const transitionFailure = captureFailure(() => {
+        if (pendingTransition !== undefined) {
+          const pending = pendingTransition;
+          pendingTransition = undefined;
+          commitTransition(pending, activeScene.state, undefined);
+          commitOrPause();
+        }
+      });
+      if (pauseFailure.failed && transitionFailure.failed) {
+        throw composeFailures(pauseFailure.value, transitionFailure.value);
       }
+      throwFailure(pauseFailure);
+      throwFailure(transitionFailure);
     },
     setScene(name) {
       assertLive();
@@ -518,14 +863,29 @@ export function createGameSessionWithDriver(definition, options) {
         options.frameDriver.cancelFrame(frameHandle);
         frameHandle = undefined;
       }
-      status = 'disposed';
       generation += 1;
       previousTimestampMs = undefined;
       accumulatorMs = 0;
       pendingTransition = undefined;
       inputBuffer.reset();
-      listeners.clear();
-      activeScene.definition.dispose?.(activeScene.state);
+      eventListeners.clear();
+      // Terminal cleanup is unconditional: `disposed` is delivered to the
+      // full listener snapshot (including the re-entrant queued pass), then
+      // every listener and the scene are released exactly once even when a
+      // status listener throws. The release flag is set BEFORE the
+      // notification so notifyStatus's finally performs the clear; for the
+      // re-entrant path the clear happens after the queued pass drains.
+      releaseStatusListeners = true;
+      const notificationFailure = captureFailure(() => setStatus('disposed'));
+      const cleanupFailure = captureFailure(() => {
+        listeners.clear();
+        disposeSceneInstance(activeScene, activeScene.state);
+      });
+      if (notificationFailure.failed && cleanupFailure.failed) {
+        throw composeFailures(notificationFailure.value, cleanupFailure.value);
+      }
+      throwFailure(notificationFailure);
+      throwFailure(cleanupFailure);
     },
     getRenderFrame() {
       const alpha = commitFrame.hardCut ? 0 : Math.max(0, Math.min(accumulatorMs / fixedStepMs, 1 - Number.EPSILON));
@@ -547,6 +907,50 @@ export function createGameSessionWithDriver(definition, options) {
           listeners.delete(listener);
         }
       });
+    },
+    addStatusListener(listener) {
+      assertLive();
+      statusListeners.add(listener);
+      diagnostics?.onStatusListenerCount?.(statusListeners.size);
+      let removed = false;
+      return Object.freeze({
+        remove() {
+          if (removed) {
+            return;
+          }
+          removed = true;
+          statusListeners.delete(listener);
+          diagnostics?.onStatusListenerCount?.(statusListeners.size);
+        }
+      });
+    },
+    addGameEventListener: (name, listener) => {
+      assertLive();
+      if (!hasEvents || !allowedEventNames.has(name)) {
+        throw new GameEventError(`Event "${String(name)}" is not declared by this game`);
+      }
+      let set = eventListeners.get(name);
+      if (set === undefined) {
+        set = new Set();
+        eventListeners.set(name, set);
+      }
+      set.add(listener);
+      let removed = false;
+      return Object.freeze({
+        remove() {
+          if (removed) {
+            return;
+          }
+          removed = true;
+          const existing = eventListeners.get(name);
+          if (existing) {
+            existing.delete(listener);
+            if (existing.size === 0) {
+              eventListeners.delete(name);
+            }
+          }
+        }
+      });
     }
   };
   return Object.freeze(session);