davidfou · davidfou · Dec 8, 2025
diff --git a/src/@types/store/index.d.ts b/src/@types/store/index.d.ts
@@ -605,6 +605,11 @@ export interface Store {
   /// Store.transaction
   transaction<Return>(actions: () => Return, doRollback?: DoRollback): Return;
 
+  internalTransaction<Return>(
+    actions: () => Return,
+    doRollback?: DoRollback,
+  ): Return;
+
   /// Store.startTransaction
   startTransaction(): this;
 

diff --git a/src/checkpoints/index.ts b/src/checkpoints/index.ts
@@ -68,7 +68,7 @@ export const createCheckpoints = getCreateFunction(
 
     const updateStore = (oldOrNew: 0 | 1, checkpointId: Id) => {
       listening = 0;
-      store.transaction(() => {
+      store.internalTransaction(() => {
         const [cellsDelta, valuesDelta] = mapGet(deltas, checkpointId) as [
           CellsDelta,
           ValuesDelta,
@@ -96,7 +96,7 @@ export const createCheckpoints = getCreateFunction(
     const clearCheckpointId = (checkpointId: Id): void => {
       mapSet(deltas, checkpointId);
       mapSet(labels, checkpointId);
-      callListeners(checkpointListeners, [checkpointId]);
+      callListeners(false, checkpointListeners, [checkpointId]);
     };
 
     const clearCheckpointIds = (checkpointIds: Ids, to?: number): void =>
@@ -157,7 +157,7 @@ export const createCheckpoints = getCreateFunction(
 
     const callListenersIfChanged = (): void => {
       if (checkpointsChanged) {
-        callListeners(checkpointIdsListeners);
+        callListeners(false, checkpointIdsListeners);
         checkpointsChanged = 0;
       }
     };
@@ -180,7 +180,7 @@ export const createCheckpoints = getCreateFunction(
         mapGet(labels, checkpointId) !== label
       ) {
         mapSet(labels, checkpointId, label);
-        callListeners(checkpointListeners, [checkpointId]);
+        callListeners(false, checkpointListeners, [checkpointId]);
       }
       return checkpoints;
     };
@@ -227,12 +227,12 @@ export const createCheckpoints = getCreateFunction(
     };
 
     const addCheckpointIdsListener = (listener: CheckpointIdsListener): Id =>
-      addListener(listener, checkpointIdsListeners);
+      addListener(false, listener, checkpointIdsListeners);
 
     const addCheckpointListener = (
       checkpointId: IdOrNull,
       listener: CheckpointListener,
-    ): Id => addListener(listener, checkpointListeners, [checkpointId]);
+    ): Id => addListener(false, listener, checkpointListeners, [checkpointId]);
 
     const delListener = (listenerId: Id): Checkpoints => {
       delListenerImpl(listenerId);
@@ -254,7 +254,7 @@ export const createCheckpoints = getCreateFunction(
     const clearForward = (): Checkpoints => {
       if (!arrayIsEmpty(forwardIds)) {
         clearCheckpointIds(forwardIds);
-        callListeners(checkpointIdsListeners);
+        callListeners(false, checkpointIdsListeners);
       }
       return checkpoints;
     };

diff --git a/src/common/definable.ts b/src/common/definable.ts
@@ -124,7 +124,7 @@ export const getDefinableFunctions = <Thing, RowValue>(
       mapSet(things, id, getDefaultThing());
       mapSet(allRowValues, id, mapNew());
       mapSet(allSortKeys, id, mapNew());
-      callListeners(thingIdListeners);
+      callListeners(true, thingIdListeners);
     }
   };
 
@@ -206,10 +206,15 @@ export const getDefinableFunctions = <Thing, RowValue>(
     addStoreListeners(
       id,
       0,
-      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
-        processRow(rowId),
+      store.addRowListener.call(
+        {isInternal: true},
+        tableId,
+        null,
+        (_store, _tableId, rowId) => processRow(rowId),
+      ),
+      store.addTableListener.call({isInternal: true}, tableId, () =>
+        processTable(),
       ),
-      store.addTableListener(tableId, () => processTable()),
     );
   };
 
@@ -219,11 +224,11 @@ export const getDefinableFunctions = <Thing, RowValue>(
     mapSet(allRowValues, id);
     mapSet(allSortKeys, id);
     delStoreListeners(id);
-    callListeners(thingIdListeners);
+    callListeners(false, thingIdListeners);
   };
 
   const addThingIdsListener = (listener: () => void) =>
-    addListener(listener, thingIdListeners);
+    addListener(false, listener, thingIdListeners);
 
   const destroy = (): void => mapForEach(storeListenerIds, delDefinition);
 

diff --git a/src/common/listeners.ts b/src/common/listeners.ts
@@ -68,13 +68,15 @@ export type ListenerArgument = IdOrNull | boolean | number | undefined;
 export type PathGetters = ((...ids: Ids) => Ids)[];
 export type ExtraArgsGetter = (ids: Ids) => any[];
 export type AddListener = (
+  isInternal: boolean,
   listener: Listener,
   idSetNode: IdSetNode,
   path?: ListenerArgument[],
   pathGetters?: PathGetters,
   extraArgsGetter?: ExtraArgsGetter,
 ) => Id;
 export type CallListeners = (
+  isInternal: boolean,
   idSetNode: IdSetNode,
   ids?: Ids,
   ...extra: any[]
@@ -159,8 +161,10 @@ export const getListenerFunctions = (
   const allListeners: IdMap<
     [Listener, IdSetNode, ListenerArgument[], PathGetters, ExtraArgsGetter]
   > = mapNew();
+  const internalListenerIds: IdSet = setNew();
 
   const addListener = (
+    isInternal: boolean,
     listener: Listener,
     idSetNode: IdSetNode,
     path?: ListenerArgument[],
@@ -184,22 +188,29 @@ export const getListenerFunctions = (
       ),
       id,
     ) as IdSet;
+    if (isInternal) {
+      internalListenerIds.add(id);
+    }
     return id;
   };
 
   const callListeners = (
+    isInternal: boolean,
     idSetNode: IdSetNode,
     ids?: Ids,
     ...extraArgs: any[]
   ): void =>
     arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
-      collForEach(set, (id: Id) =>
+      collForEach(set, (id: Id) => {
+        if (internalListenerIds.has(id) !== isInternal) {
+          return;
+        }
         (mapGet(allListeners, id) as any)[0](
           thing,
           ...(ids ?? []),
           ...extraArgs,
-        ),
-      ),
+        );
+      }),
     );
 
   const delListener = (id: Id): Ids =>
@@ -215,6 +226,7 @@ export const getListenerFunctions = (
       );
       mapSet(allListeners, id);
       releaseId(id);
+      internalListenerIds.delete(id);
       return idOrNulls;
     }) as Ids;
 

diff --git a/src/indexes/index.ts b/src/indexes/index.ts
@@ -204,10 +204,10 @@ export const createIndexes = getCreateFunction((store: Store): Indexes => {
         }
 
         if (sliceIdsChanged) {
-          callListeners(sliceIdsListeners, [indexId]);
+          callListeners(false, sliceIdsListeners, [indexId]);
         }
         collForEach(changedSlices, (sliceId) =>
-          callListeners(sliceRowIdsListeners, [indexId, sliceId]),
+          callListeners(false, sliceRowIdsListeners, [indexId, sliceId]),
         );
       },
       getRowCellFunction(getSliceIdOrIds),
@@ -256,13 +256,14 @@ export const createIndexes = getCreateFunction((store: Store): Indexes => {
   const addSliceIdsListener = (
     indexId: IdOrNull,
     listener: SliceIdsListener,
-  ): Id => addListener(listener, sliceIdsListeners, [indexId]);
+  ): Id => addListener(false, listener, sliceIdsListeners, [indexId]);
 
   const addSliceRowIdsListener = (
     indexId: IdOrNull,
     sliceId: IdOrNull,
     listener: SliceRowIdsListener,
-  ): Id => addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);
+  ): Id =>
+    addListener(false, listener, sliceRowIdsListeners, [indexId, sliceId]);
 
   const delListener = (listenerId: Id): Indexes => {
     delListenerImpl(listenerId);

diff --git a/src/metrics/index.ts b/src/metrics/index.ts
@@ -116,7 +116,13 @@ export const createMetrics = getCreateFunction((store: Store): Metrics => {
 
         if (newMetric != oldMetric) {
           setMetric(metricId, newMetric);
-          callListeners(metricListeners, [metricId], newMetric, oldMetric);
+          callListeners(
+            false,
+            metricListeners,
+            [metricId],
+            newMetric,
+            oldMetric,
+          );
         }
       },
       getRowCellFunction(getNumber, 1),
@@ -132,7 +138,7 @@ export const createMetrics = getCreateFunction((store: Store): Metrics => {
   const addMetricListener = (
     metricId: IdOrNull,
     listener: MetricListener,
-  ): Id => addListener(listener, metricListeners, [metricId]);
+  ): Id => addListener(false, listener, metricListeners, [metricId]);
 
   const delListener = (listenerId: Id): Metrics => {
     delListenerImpl(listenerId);

diff --git a/src/persisters/common/create.ts b/src/persisters/common/create.ts
@@ -149,7 +149,7 @@ export const createCustomPersister = <
   const setStatus = (newStatus: StatusValues): void => {
     if (newStatus != status) {
       status = newStatus;
-      callListeners(statusListeners, undefined, status);
+      callListeners(false, statusListeners, undefined, status);
     }
   };
 
@@ -332,7 +332,7 @@ export const createCustomPersister = <
   const getStatus = (): StatusValues => status;
 
   const addStatusListener = (listener: StatusListener): Id =>
-    addListener(listener, statusListeners);
+    addListener(false, listener, statusListeners);
 
   const delListener = (listenerId: Id): Store => {
     delListenerImpl(listenerId);

diff --git a/src/queries/index.ts b/src/queries/index.ts
@@ -484,7 +484,7 @@ export const createQueries = getCreateFunction((store: Store): Queries => {
                   arg2,
                 ]) as [Id, Id, Id]),
         );
-      selectJoinWhereStore.transaction(() =>
+      selectJoinWhereStore.internalTransaction(() =>
         arrayEvery(wheres, (where) => where(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
               setOrDelCell(
@@ -543,7 +543,7 @@ export const createQueries = getCreateFunction((store: Store): Queries => {
     };
 
     const {3: joinedTableIds} = mapGet(joins, undefined) as JoinClause;
-    selectJoinWhereStore.transaction(() =>
+    selectJoinWhereStore.internalTransaction(() =>
       addStoreListeners(
         queryId,
         1,

diff --git a/src/relationships/index.ts b/src/relationships/index.ts
@@ -164,14 +164,23 @@ export const createRelationships = getCreateFunction(
           change();
 
           collForEach(changedLocalRows, (localRowId) =>
-            callListeners(remoteRowIdListeners, [relationshipId, localRowId]),
+            callListeners(false, remoteRowIdListeners, [
+              relationshipId,
+              localRowId,
+            ]),
           );
           collForEach(changedRemoteRows, (remoteRowId) =>
-            callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),
+            callListeners(false, localRowIdsListeners, [
+              relationshipId,
+              remoteRowId,
+            ]),
           );
           collForEach(changedLinkedRows, (firstRowId) => {
             delLinkedRowIdsCache(relationshipId, firstRowId);
-            callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);
+            callListeners(false, linkedRowIdsListeners, [
+              relationshipId,
+              firstRowId,
+            ]);
           });
         },
         getRowCellFunction(getRemoteRowId),
@@ -219,14 +228,17 @@ export const createRelationships = getCreateFunction(
       localRowId: IdOrNull,
       listener: RemoteRowIdListener,
     ): Id =>
-      addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);
+      addListener(false, listener, remoteRowIdListeners, [
+        relationshipId,
+        localRowId,
+      ]);
 
     const addLocalRowIdsListener = (
       relationshipId: IdOrNull,
       remoteRowId: IdOrNull,
       listener: LocalRowIdsListener,
     ): Id =>
-      addListener(listener, localRowIdsListeners, [
+      addListener(false, listener, localRowIdsListeners, [
         relationshipId,
         remoteRowId,
       ]);
@@ -237,7 +249,7 @@ export const createRelationships = getCreateFunction(
       listener: LinkedRowIdsListener,
     ): Id => {
       getLinkedRowIdsCache(relationshipId, firstRowId);
-      return addListener(listener, linkedRowIdsListeners, [
+      return addListener(false, listener, linkedRowIdsListeners, [
         relationshipId,
         firstRowId,
       ]);