@inglorious/store 12.1.1 → 12.3.0

package/README.md

@@ -522,7 +522,7 @@ const types = {
         const { name } = api.getEntity("user")
         const response = await fetch(`/api/todos/${name}`)
         const data = await response.json()
-        api.notify("todosLoaded", todos)
+        api.notify("todosLoaded", data)
       } catch (error) {
         api.notify("loadFailed", error.message)
       }
@@ -553,6 +553,11 @@ Notice: you don't need pending/fulfilled/rejected actions. You stay in control o
 
 All events triggered via `api.notify()` enter the queue and process together, maintaining predictability and testability.
 
+Two things to keep in mind:
+
+- **`entity` ends at the first `await`.** `entity`, and every object or array read from it, is a draft of the current update, revoked when the update ends, and the update does not wait for your `await`. After it, writing to `entity` or reading anything taken from it throws. Write before the first `await`, then notify an event that does the rest, as `todosLoaded` does above. The same goes for payloads: pass a copy (`{ ...entity.values }`), not the draft, to a handler that reads it after an `await`.
+- **`api.getEntity()` reads the state from before the update.** A handler cannot see what an earlier handler in the same chain of events changed: see [State swapping](#state-swapping).
+
 ### `handleAsync`
 
 The `handleAsync` helper generates a set of event handlers representing the lifecycle of an async operation.
@@ -611,6 +616,8 @@ fetchTodosFinally
 
 Each step is an **event handler**, not an implicit callback.
 
+Each call gets a `callId`, and every event of that call carries it: `Start` and `Run` get `{ payload, callId }`, `Success` gets `{ result, callId }`, `Error` gets `{ error, callId }` and `Finally` gets `{ callId }`. The `start`, `run`, `success`, `error` and `finally` handlers still receive the payload, result or error alone; the `callId` matters to code that listens to the events directly, such as `optimistic`.
+
 ---
 
 ### Optional `start` handler
@@ -685,6 +692,26 @@ const saveSettings = optimistic(
 
 The wrapper snapshots the keys in the patch, applies them in `Start`, restores the previous values in `Error`, and leaves `Success`/`Finally` handlers in control of cleanup.
 
+Each call keeps its own snapshot, so saves on the same entity can overlap. A failed call restores the keys it patched, except those a later pending call patched too: those go back to what they were before both once that call fails as well, or stay as that call left them.
+
+A patch built on the current value, such as a list with a temporary item added, cannot be undone key by key when two calls change the same list. Give `rollback` to undo the call's own change in place of restoring the snapshot:
+
+```ts
+const addTodo = optimistic(
+  handleAsync("addTodo", {
+    async run(todo) {
+      return api.add(todo)
+    },
+  }),
+  (entity, todo) => ({ todos: [...entity.todos, { ...todo, pending: true }] }),
+  {
+    rollback(entity, todo) {
+      entity.todos = entity.todos.filter(({ id }) => id !== todo.id)
+    },
+  },
+)
+```
+
 ---
 
 ### Reading a store from outside a handler
@@ -1632,7 +1659,52 @@ interface SalesEntity extends ChartEntity {
 // types: { Router, Sales: Chart }
 ```
 
-**5. Test your handlers**
+**5. Check the events you send**
+
+The type declarations already list every event and its payload, so the api can check what `notify` sends. Read the events from them with `EventsOf`, and give them to the api as its third type argument:
+
+```typescript
+// types/index.d.ts
+import type { EventsOf } from "@inglorious/store"
+
+export type AppEvents = EventsOf<CounterType | LabelType>
+// { increment: void; add: number; copyLabel: void; ...the label's events }
+
+export type AppApi = Api<AppEntity, AppState, AppEvents>
+```
+
+Now every handler's `api.notify` checks the event's name, wherever it is sent (`"add"`, `"Counter:add"`, `` `#${entity.id}:add` ``), and its payload:
+
+```typescript
+api.notify(`#${entity.id}:add`, 2) // fine
+api.notify(`#${entity.id}:ad`, 2) // error: no type answers `ad`
+api.notify(`#${entity.id}:add`, "2") // error: `add` takes a number
+api.notify(`#${entity.id}:increment`, 1) // error: `increment` takes no payload
+```
+
+The store's own events (`add`, `remove`, `patch`, `replace`, `pause`, `resume`, `update`) are always there. Only the event's name is checked, not the target before it, because the target is usually built at runtime. Pass the events to `createStore<AppEntity, AppState, AppEvents>` too, so that `store.notify` checks them, and `mount` gives them to the root render. A typed api is still an `Api`: components that take any app's api accept it.
+
+Without the third type argument, `notify` takes any name and any payload, as before.
+
+**6. Give sub-renderers their props**
+
+Every render method takes props first: `render(props, api)`, where a type's props are its entity, and sub-renderers that draw one item, `renderX(props, ownProps, api)`, which get the component's props, then the item's own (`renderLine(props, line, api)`). `EntityType` reads every member as a handler, whose first parameter is the entity, so it rejects sub-renderers whose props are not the entity. `defineType` checks each member by its name instead: `render` takes the entity as its props, a sub-renderer keeps the types it declares, and every other member is a handler, whose entity and api are inferred:
+
+```typescript
+import { defineType } from "@inglorious/store"
+
+export const Scoreboard = defineType<ScoreboardEntity, AppApi>()({
+  ...template, // renderScoreboard(props, api), renderContender(props, speaker, api), ...
+  render(props, api) {
+    const debate = api.getEntity("debate")
+    return this.renderScoreboard({ ...props, memory: debate?.memory }, api)
+  },
+})
+```
+
+Inside its methods, `this` is the behavior, so `this.renderScoreboard` is checked too. It takes the entity and the api first, then the behavior, because TypeScript cannot infer one while being told the others. The result is an `EntityType`, so it goes in `types` or in a list of behaviors like any other: `[Chat, handlers, fsm(states), defineType<DebateEntity, AppApi>()({ ...template, render })]`.
+
+**7. Test your handlers**
 
 ```typescript
 import { trigger } from "@inglorious/store/test"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/store",
-  "version": "12.1.1",
+  "version": "12.3.0",
   "description": "A state manager for real-time, collaborative apps, inspired by game development patterns and compatible with Redux.",
   "author": "Matteo Antony Mistretta <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -78,11 +78,11 @@
     "mutative": "^1.3.0"
   },
   "peerDependencies": {
-    "@inglorious/utils": "^5.1.0"
+    "@inglorious/utils": "^5.2.0"
   },
   "devDependencies": {
     "@inglorious/eslint-config": "1.2.0",
-    "@inglorious/utils": "5.1.0",
+    "@inglorious/utils": "5.2.0",
     "@reduxjs/toolkit": "^2.12.0",
     "prettier": "^3.9.6",
     "typescript": "~7.0.2",
@@ -90,7 +90,7 @@
     "vitest": "^5.0.0"
   },
   "engines": {
-    "node": ">= 22"
+    "node": ">= 26"
   },
   "scripts": {
     "format": "prettier --write .",

package/src/behaviors/async.js

@@ -36,6 +36,11 @@
  *   - "type": notify `typeName:event` (broadcasts to all entities of this type)
  *   - "global": notify `event` (global broadcast to any listener)
  *
+ * Each call gets a `callId`, and every event of that call carries it: `Start`
+ * and `Run` get `{ payload, callId }`, `Success` gets `{ result, callId }`,
+ * `Error` gets `{ error, callId }` and `Finally` gets `{ callId }`. The
+ * handlers above still receive the payload, result or error alone.
+ *
  * @returns {Object} An object containing the generated event handlers that can be spread into a type:
  *   - `[type]`: Main trigger - dispatches Start (if defined) and Run events
  *   - `[typeStart]`: (if start handler provided) Executes the start handler
@@ -148,38 +153,39 @@ export function handleAsync(type, handlers, options = {}) {
 
   const asyncHandlers = {
     [type](entity, payload, api) {
+      const callId = nextCallId()
+
       if (handlers.start) {
-        notify(api, entity, `${type}Start`, payload)
+        notify(api, entity, `${type}Start`, { payload, callId })
       }
 
-      notify(api, entity, `${type}Run`, payload)
+      notify(api, entity, `${type}Run`, { payload, callId })
     },
 
     ...(handlers.start && {
-      [`${type}Start`](entity, payload, api) {
+      [`${type}Start`](entity, { payload }, api) {
         handlers.start(entity, payload, api)
       },
     }),
 
-    async [`${type}Run`](entity, payload, api) {
-      // Snapshot routing keys before await — mutative revokes draft proxies after the patch.
+    async [`${type}Run`](entity, { payload, callId }, api) {
       const scopedEntity = { id: entity.id, type: entity.type }
 
       try {
         const result = await handlers.run(payload, api)
-        notify(api, scopedEntity, `${type}Success`, result)
+        notify(api, scopedEntity, `${type}Success`, { result, callId })
       } catch (error) {
-        notify(api, scopedEntity, `${type}Error`, error)
+        notify(api, scopedEntity, `${type}Error`, { error, callId })
       } finally {
-        notify(api, scopedEntity, `${type}Finally`)
+        notify(api, scopedEntity, `${type}Finally`, { callId })
       }
     },
 
-    [`${type}Success`](entity, result, api) {
+    [`${type}Success`](entity, { result }, api) {
       handlers.success?.(entity, result, api)
     },
 
-    [`${type}Error`](entity, error, api) {
+    [`${type}Error`](entity, { error }, api) {
       handlers.error?.(entity, error, api)
     },
 
@@ -196,4 +202,17 @@ export function handleAsync(type, handlers, options = {}) {
   return asyncHandlers
 }
 
+const NEXT = 1
+
+let lastCallId = 0
+
+/**
+ * A new id for one call of an async behavior, which its events carry.
+ * @returns {number}
+ */
+export function nextCallId() {
+  lastCallId += NEXT
+  return lastCallId
+}
+
 export const ASYNC_META = Symbol.for("@inglorious/store/asyncMeta")

package/src/behaviors/optimistic.js

@@ -1,6 +1,8 @@
-import { ASYNC_META } from "./async.js"
+import { ASYNC_META, nextCallId } from "./async.js"
 
 const START = 0
+const NOT_FOUND = -1
+const ONE_CALL = 1
 
 /**
  * Decorates an async behavior with optimistic update boilerplate.
@@ -8,6 +10,16 @@ const START = 0
  * Pass either a static shallow patch object or a factory that returns one.
  * The wrapper applies the patch during `Start` and rolls it back during `Error`.
  *
+ * Each call keeps its own snapshot, so calls on the same entity can overlap. A
+ * failed call restores the keys it patched, except those a later pending call
+ * patched too: that call's own rollback then restores them to what they were
+ * before both.
+ *
+ * A patch built on the current value, such as a list with a temporary item
+ * added, cannot be undone key by key when two calls change the same list. Give
+ * `rollback` instead: it undoes the call's own change in place of restoring
+ * the snapshot.
+ *
  * @template {import('../store').BaseEntity} TEntity
  * @template TPayload
  * @template TResult
@@ -16,6 +28,9 @@ const START = 0
  * @param {import('./async').AsyncEvents<TType, TEntity, TPayload, TResult>} behavior
  * @param {Record<string, any> | ((entity: TEntity, payload: TPayload, api: import('../store').Api) => Record<string, any> | null | undefined)} optimistic
  *   Shallow patch applied optimistically on start, or a factory that returns it.
+ * @param {object} [options]
+ * @param {(entity: TEntity, payload: TPayload, api: import('../store').Api) => void} [options.rollback]
+ *   Undoes a failed call's change, in place of restoring the snapshot.
  *
  * @returns {import('./async').AsyncEvents<TType, TEntity, TPayload, TResult>}
  *
@@ -46,8 +61,23 @@ const START = 0
  *     data: { ...entity.data, ...payload },
  *   }),
  * )
+ *
+ * @example
+ * const addTodo = optimistic(
+ *   handleAsync("addTodo", {
+ *     async run(todo) {
+ *       return api.add(todo)
+ *     },
+ *   }),
+ *   (entity, todo) => ({ todos: [...entity.todos, todo] }),
+ *   {
+ *     rollback(entity, todo) {
+ *       entity.todos = entity.todos.filter(({ id }) => id !== todo.id)
+ *     },
+ *   },
+ * )
  */
-export function optimistic(behavior, optimistic) {
+export function optimistic(behavior, optimistic, { rollback } = {}) {
   const { type, scope } = resolveAsyncMeta(behavior)
 
   const startEvent = `${type}Start`
@@ -55,7 +85,8 @@ export function optimistic(behavior, optimistic) {
   const errorEvent = `${type}Error`
   const finallyEvent = `${type}Finally`
 
-  const snapshots = new Map()
+  /** The calls still pending, by entity id, in the order they started. */
+  const pending = new Map()
 
   function notify(api, entity, event, payload) {
     switch (scope) {
@@ -75,19 +106,16 @@ export function optimistic(behavior, optimistic) {
     ...behavior,
 
     [type](entity, payload, api) {
-      notify(api, entity, startEvent, payload)
-      notify(api, entity, runEvent, payload)
+      const callId = nextCallId()
+      notify(api, entity, startEvent, { payload, callId })
+      notify(api, entity, runEvent, { payload, callId })
     },
 
-    [startEvent](entity, payload, api) {
+    [startEvent](entity, event, api) {
+      const { payload, callId } = event
       const patch = toPatch(optimistic, entity, payload, api)
 
-      if (!patch) {
-        behavior[startEvent]?.(entity, payload, api)
-        return
-      }
-
-      if (typeof patch !== "object") {
+      if (patch && typeof patch !== "object") {
         throw new TypeError(
           "optimistic expects the patch to be an object or a factory that returns an object",
         )
@@ -95,25 +123,46 @@ export function optimistic(behavior, optimistic) {
 
       const key = getEntityKey(entity)
       const currentEntity = api.getEntity?.(key) ?? entity
-      snapshots.set(key, snapshotPatch(currentEntity, patch))
-      Object.assign(entity, patch)
-
-      behavior[startEvent]?.(entity, payload, api)
+      const calls = pending.get(key) ?? []
+      calls.push({
+        callId,
+        payload,
+        snapshot: snapshotPatch(currentEntity, patch ?? {}),
+      })
+      pending.set(key, calls)
+      if (patch) Object.assign(entity, patch)
+
+      behavior[startEvent]?.(entity, event, api)
     },
 
     [runEvent]: behavior[runEvent],
 
-    [errorEvent](entity, error, api) {
-      const key = getEntityKey(entity)
-      restorePatch(entity, snapshots.get(key))
-      behavior[errorEvent]?.(entity, error, api)
+    [errorEvent](entity, event, api) {
+      const calls = pending.get(getEntityKey(entity)) ?? []
+      const index = calls.findIndex(({ callId }) => callId === event.callId)
+
+      if (index !== NOT_FOUND) {
+        const [call] = calls.splice(index, ONE_CALL)
+        if (rollback) {
+          rollback(entity, call.payload, api)
+        } else {
+          restorePatch(entity, call.snapshot, calls.slice(index))
+        }
+      }
+
+      behavior[errorEvent]?.(entity, event, api)
     },
 
-    [finallyEvent](entity, payload, api) {
+    [finallyEvent](entity, event, api) {
       try {
-        behavior[finallyEvent]?.(entity, payload, api)
+        behavior[finallyEvent]?.(entity, event, api)
       } finally {
-        snapshots.delete(getEntityKey(entity))
+        const key = getEntityKey(entity)
+        const calls = (pending.get(key) ?? []).filter(
+          ({ callId }) => callId !== event?.callId,
+        )
+        if (calls.length) pending.set(key, calls)
+        else pending.delete(key)
       }
     },
   }
@@ -168,27 +217,21 @@ function toPatch(optimistic, entity, payload, api) {
 }
 
 function snapshotPatch(entity, patch) {
-  const entries = []
-
-  for (const key of Object.keys(patch)) {
-    entries.push([
+  return new Map(
+    Object.keys(patch).map((key) => [
       key,
-      Object.prototype.hasOwnProperty.call(entity, key),
-      entity[key],
-    ])
-  }
-
-  return entries
+      { existed: Object.hasOwn(entity, key), value: entity[key] },
+    ]),
+  )
 }
 
-function restorePatch(entity, entries) {
-  if (!entries) {
-    return
-  }
-
-  for (const [key, existed, value] of entries) {
-    if (existed) {
-      entity[key] = value
+function restorePatch(entity, snapshot, laterCalls) {
+  for (const [key, before] of snapshot) {
+    const later = laterCalls.find((call) => call.snapshot.has(key))
+    if (later) {
+      later.snapshot.set(key, before)
+    } else if (before.existed) {
+      entity[key] = before.value
     } else {
       delete entity[key]
     }

package/src/behaviors/state-machine/fsm.js

@@ -20,12 +20,6 @@ export function fsm(states) {
           [eventName](entity, event, api) {
             const from = entity.state
 
-            // A state answers for itself, and what it has to say replaces what the type
-            // would have said. The type-stage handler is the default -- the thing every
-            // state would otherwise do -- and a state takes it over by naming the same
-            // event, which is how a state can take the way out for itself rather than
-            // being quit by, without whatever answers by default having to know that
-            // state exists.
             const handler = states[entity.state]?.[eventName] ?? type[eventName]
 
             handler?.(entity, event, api)

package/src/behaviors/state-machine/scenes.js

@@ -59,10 +59,6 @@ export function scenes(scenesByState) {
         continue
       }
 
-      // The same thing stands on both sides of the move, so it is neither added nor
-      // removed -- but it may be wanted to be a different thing now, and then only what
-      // has actually changed is merged over it. That is what leaves a shared thing where
-      // the world had put it when the next state says nothing different about it.
       const previous = leaving.find(({ id }) => id === added.id)
 
       if (!isDeepEqual(previous, added)) {
@@ -78,8 +74,6 @@ export function scenes(scenesByState) {
       build(entity, entity.state, api)
     },
 
-    // The announcement is broadcast and carries the id, so that anything else listening
-    // for it can tell which machine moved. This one is only interested in its own.
     stateChange(entity, { entityId, to }, api) {
       if (entityId !== entity.id) return
 

package/src/client/devtools.js

@@ -2,21 +2,10 @@ import { deserialize } from "@inglorious/utils/object.js"
 
 const LAST_STATE = 1
 
-// HMR-safe container to persist a single DevTools connection across Vite reloads.
-// Uses import.meta.hot.data when available (preferred), falls back to module scope.
 const globalContainer = import.meta.hot
   ? ((import.meta.hot.data ??= {}).__INGLORIOUS_DEVTOOLS__ ??= {})
   : {}
 
-// connection shape: {
-//   devToolsInstance,
-//   unsubscribe,
-//   store,
-//   updateMode,
-//   restoreSetState: () => void,
-// }
-
-// Unified API for cleaner integration across apps and engine
 export function createDevtools(config = {}) {
   return {
     connect(store) {
@@ -51,12 +40,10 @@ export function createDevtools(config = {}) {
 function connectDevTools(store, config = {}) {
   const updateMode = config.updateMode ?? "auto"
 
-  // Prevent duplicate connections; rewire if store or update mode changed
   const existing = getConnection()
   if (existing) {
     const sameMode = existing.updateMode === updateMode
     if (sameMode) {
-      // Hot-swap store without resetting DevTools history
       existing.restoreSetState?.()
       const baseSetState = store.setState
       const restoreSetState =
@@ -79,7 +66,6 @@ function connectDevTools(store, config = {}) {
       existing.restoreSetState = restoreSetState
     }
 
-    // Different update mode: fully disconnect previous and proceed
     try {
       existing.unsubscribe?.()
     } finally {
@@ -104,7 +90,6 @@ function connectDevTools(store, config = {}) {
       : () => {
           // noop; we didn't wrap setState
         }
-  // Only add setState side-effects in auto update mode; manual update mode logs explicitly from engine.
   if (updateMode === "auto") {
     store.setState = (newState) => {
       baseSetState(newState)
@@ -114,19 +99,17 @@ function connectDevTools(store, config = {}) {
 
   const devToolsInstance = window.__REDUX_DEVTOOLS_EXTENSION__.connect({
     name,
-    // predicate: // doesn't work
-    // @see https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md#features
     features: {
-      pause: true, // start/pause recording of dispatched actions
-      lock: true, // lock/unlock dispatching actions and side effects
-      persist: true, // persist states on page reloading
-      export: true, // export history of actions in a file
-      import: "custom", // import history of actions from a file
-      jump: false, // jump back and forth (time travelling)
-      skip: false, // skip (cancel) actions
-      reorder: false, // drag and drop actions in the history list
-      dispatch: true, // dispatch custom actions or action creators
-      test: false, // generate tests for the selected actions
+      pause: true,
+      lock: true,
+      persist: true,
+      export: true,
+      import: "custom",
+      jump: false,
+      skip: false,
+      reorder: false,
+      dispatch: true,
+      test: false,
     },
   })
 
@@ -154,9 +137,6 @@ function connectDevTools(store, config = {}) {
 }
 
 function disconnectDevTools() {
-  // The `disconnect` method on the devToolsInstance is not available in all
-  // environments or versions of the extension.
-  // Safest is to unsubscribe and release our reference, and restore setState.
   const existing = getConnection()
   if (!existing) return
   try {
@@ -171,7 +151,6 @@ function handleDispatch(message) {
   const { store } = getConnection() ?? {}
   if (!store) return
   switch (message.payload.type) {
-    // reset button
     case "RESET": {
       store.reset()
       const existing = getConnection()
@@ -179,21 +158,18 @@ function handleDispatch(message) {
       break
     }
 
-    // revert button
     case "ROLLBACK": {
       const newState = deserialize(message.state)
       store.setState(newState)
       break
     }
 
-    // commit button
     case "COMMIT": {
       const existing = getConnection()
       existing?.devToolsInstance?.init(store.getState())
       break
     }
 
-    // import from file button
     case "IMPORT_STATE": {
       const { computedStates, actionsById } = message.payload.nextLiftedState
 

package/src/client/multiplayer-middleware.js

@@ -18,7 +18,6 @@ export function multiplayerMiddleware(config = {}) {
   let ws = null
   const localQueue = []
 
-  // The middleware function that will be applied to the store.
   return (store) => {
     const next = store.dispatch
     store.dispatch = (event) => send(store, event, next)
@@ -38,7 +37,6 @@ export function multiplayerMiddleware(config = {}) {
       return next(event)
     }
 
-    // Establish the connection on the first event.
     if (!ws) {
       establishConnection(store)
     }
@@ -51,8 +49,6 @@ export function multiplayerMiddleware(config = {}) {
       }
     }
 
-    // Pass the event to the next middleware in the chain,
-    // which is eventually the store's original dispatch function.
     return next(event)
   }
 
@@ -60,18 +56,12 @@ export function multiplayerMiddleware(config = {}) {
    * Attempts to establish a WebSocket connection to the server.
    */
   function establishConnection(store) {
-    // If a connection already exists, close it first.
     if (ws) {
       ws.close()
     }
     ws = new WebSocket(serverUrl)
 
-    // =====================================================================
-    // WebSocket Event Handlers
-    // =====================================================================
-
     ws.onopen = () => {
-      // Send any queued events to the server.
       while (localQueue.length) {
         ws.send(serialize(localQueue.shift()))
       }
@@ -81,22 +71,19 @@ export function multiplayerMiddleware(config = {}) {
       const serverEvent = deserialize(event.data)
 
       if (serverEvent.type === "stateInit") {
-        // Merge the server's initial state with the client's local state.
         const nextState = extend(store.getState(), serverEvent.payload)
         store.setState(nextState)
       } else {
-        // Dispatch the event to the local store to update the client's state.
         store.dispatch({ ...serverEvent, fromServer: true })
       }
     }
 
     ws.onclose = () => {
-      // Attempt to reconnect after a short delay.
       setTimeout(() => establishConnection(store), reconnectionDelay)
     }
 
     ws.onerror = () => {
-      ws.close() // The 'onclose' handler will trigger the reconnect.
+      ws.close()
     }
   }
 }

package/src/event-map.js

@@ -8,6 +8,10 @@ const SPLIT_LIMIT = 2
 /**
  * A class to manage the mapping of event names to the entity IDs that handle them.
  * This is used for optimized event handling with support for scoped events.
+ *
+ * Do not replace it with a scan of all entities: every event would then visit
+ * every entity, and a game dispatching dozens of events a frame over thousands
+ * of entities cannot afford that (see the comparison in event-map.test.js).
  */
 export class EventMap {
   /**
@@ -118,13 +122,11 @@ export class EventMap {
       return entitySet && entitySet.has(targetEntityId) ? [targetEntityId] : []
     }
 
-    // form:submit - all entities of this type
     if (targetType) {
       const entitySet = typeMap.get(targetType)
       return entitySet ? Array.from(entitySet) : []
     }
 
-    // submit - all entities with this handler (broadcast)
     const allEntities = []
     for (const entitySet of typeMap.values()) {
       allEntities.push(...entitySet)