teamplay 0.4.0-alpha.80 → 0.4.0-alpha.81

package/orm/Aggregation.js

@@ -1,34 +1,54 @@
 import { raw } from '@nx-js/observer-util'
-import { set as _set, del as _del, getRaw } from './dataTree.js'
+import { getRaw } from './dataTree.js'
 import getSignal from './getSignal.js'
-import { QuerySubscriptions, hashQuery, Query, HASH, PARAMS, COLLECTION_NAME, parseQueryHash } from './Query.js'
+import {
+  QuerySubscriptions,
+  hashQuery,
+  Query,
+  HASH,
+  PARAMS,
+  COLLECTION_NAME,
+  parseQueryHash
+} from './Query.js'
 import Signal, { SEGMENTS } from './Signal.js'
 import { getIdFieldsForSegments, isPlainObject } from './idFields.js'
+import { delPrivateData, getPrivateData, setPrivateData } from './privateData.js'
 
 export const IS_AGGREGATION = Symbol('is aggregation signal')
 export const AGGREGATIONS = '$aggregations'
 
 class Aggregation extends Query {
   _initData () {
-    {
-      const extra = raw(this.shareQuery.extra)
-      injectAggregationIds(extra, this.collectionName)
-      _set([AGGREGATIONS, this.hash], extra)
-    }
+    this._syncAllRootsData()
 
     this.shareQuery.on('extra', extra => {
       extra = raw(extra)
       injectAggregationIds(extra, this.collectionName)
-      _set([AGGREGATIONS, this.hash], extra)
+      this._forEachRoot(rootId => {
+        setPrivateData(rootId, [AGGREGATIONS, this.hash], extra)
+      })
     })
   }
 
+  _syncRootData (rootId) {
+    if (!this.shareQuery) return
+    const extra = raw(this.shareQuery.extra)
+    injectAggregationIds(extra, this.collectionName)
+    setPrivateData(rootId, [AGGREGATIONS, this.hash], extra)
+  }
+
+  _removeRootData (rootId) {
+    delPrivateData(rootId, [AGGREGATIONS, this.hash])
+  }
+
   _removeData () {
-    _del([AGGREGATIONS, this.hash])
+    this._forEachRoot(rootId => this._removeRootData(rootId))
+    this.rootIds.clear()
   }
 }
 
 export const aggregationSubscriptions = new QuerySubscriptions(Aggregation)
+aggregationSubscriptions.runtimeKind = 'aggregation'
 
 function injectAggregationIds (extra, collectionName) {
   if (!Array.isArray(extra)) return
@@ -44,13 +64,14 @@ function injectAggregationIds (extra, collectionName) {
 
 export function getAggregationSignal (collectionName, params, options) {
   params = JSON.parse(JSON.stringify(params))
-  const hash = hashQuery(collectionName, params)
+  const transportHash = hashQuery(collectionName, params)
+  const { root, signalOptions } = parseAggregationSignalOptions(options)
 
-  const $aggregation = getSignal(undefined, [AGGREGATIONS, hash], options)
+  const $aggregation = getSignal(root, [AGGREGATIONS, transportHash], signalOptions)
   $aggregation[IS_AGGREGATION] ??= true
   $aggregation[COLLECTION_NAME] ??= collectionName
   $aggregation[PARAMS] ??= params
-  $aggregation[HASH] ??= hash
+  $aggregation[HASH] ??= transportHash
   return $aggregation
 }
 
@@ -65,10 +86,13 @@ export function isAggregationSignal ($signal) {
 
 // example: ['$aggregations', '{"active":true}', 42]
 //          AND only if it also has either '_id' or 'id' field inside
-export function getAggregationDocId (segments, method = getRaw) {
+export function getAggregationDocId (segments, rootId, method) {
   if (!(segments.length >= 3)) return
   if (!(segments[0] === AGGREGATIONS)) return
   if (!(typeof segments[2] === 'number')) return
+  if (typeof method !== 'function') {
+    method = path => rootId == null ? getRaw(path) : getPrivateData(rootId, path)
+  }
   const docId = method([...segments.slice(0, 3), '_id']) || method([...segments.slice(0, 3), 'id'])
   return docId
 }
@@ -80,3 +104,14 @@ export function getAggregationCollectionName (segments) {
   const { collectionName } = parseQueryHash(hash)
   return collectionName
 }
+
+function parseAggregationSignalOptions (options) {
+  if (!options || typeof options !== 'object') {
+    return {
+      root: undefined,
+      signalOptions: {}
+    }
+  }
+  const { root, ...signalOptions } = options
+  return { root, signalOptions }
+}

package/orm/Compat/SignalCompat.js

@@ -8,23 +8,14 @@ import {
   isPublicCollectionSignal,
   isPublicDocumentSignal
 } from '../SignalBase.js'
-import { getRoot, ROOT, getRootSignal, GLOBAL_ROOT_ID } from '../Root.js'
+import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID, unregisterRootFinalizer } from '../Root.js'
 import { publicOnly, fetchOnly, setFetchOnly } from '../connection.js'
 import { docSubscriptions } from '../Doc.js'
 import { IS_QUERY, getQuerySignal, querySubscriptions } from '../Query.js'
 import { IS_AGGREGATION, aggregationSubscriptions, getAggregationSignal } from '../Aggregation.js'
 import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from '../idFields.js'
 import {
-  del as _del,
-  setReplace as _setReplace,
   incrementPublic as _incrementPublic,
-  arrayPush as _arrayPush,
-  arrayUnshift as _arrayUnshift,
-  arrayInsert as _arrayInsert,
-  arrayPop as _arrayPop,
-  arrayShift as _arrayShift,
-  arrayRemove as _arrayRemove,
-  arrayMove as _arrayMove,
   arrayPushPublic as _arrayPushPublic,
   arrayUnshiftPublic as _arrayUnshiftPublic,
   arrayInsertPublic as _arrayInsertPublic,
@@ -32,19 +23,32 @@ import {
   arrayShiftPublic as _arrayShiftPublic,
   arrayRemovePublic as _arrayRemovePublic,
   arrayMovePublic as _arrayMovePublic,
-  stringInsertLocal as _stringInsertLocal,
-  stringRemoveLocal as _stringRemoveLocal,
   stringInsertPublic as _stringInsertPublic,
   stringRemovePublic as _stringRemovePublic
 } from '../dataTree.js'
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from './eventsCompat.js'
 import { waitForImperativeQueryReady } from './queryReadiness.js'
 import { normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js'
-import { setRefLink, removeRefLink, getRefLinks } from './refRegistry.js'
+import { setRefLink, removeRefLink, getAllRefLinks } from './refRegistry.js'
 import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js'
 import { runInBatch } from '../batchScheduler.js'
 import { runInSilentContext, runInModelEventsSilentContext } from './silentContext.js'
 import universal$ from '../../react/universal$.js'
+import { getRootContext } from '../rootContext.js'
+import disposeRootContext from '../disposeRootContext.js'
+import {
+  arrayInsertPrivateData,
+  arrayMovePrivateData,
+  arrayPopPrivateData,
+  arrayPushPrivateData,
+  arrayRemovePrivateData,
+  arrayShiftPrivateData,
+  arrayUnshiftPrivateData,
+  delPrivateData,
+  setReplacePrivateData,
+  stringInsertPrivateData,
+  stringRemovePrivateData
+} from '../privateData.js'
 
 class SignalCompat extends Signal {
   static ID_FIELDS = ['_id', 'id']
@@ -100,10 +104,12 @@ class SignalCompat extends Signal {
     if (arguments.length < 1 || arguments.length > 3) throw Error('Signal.query() expects one to three arguments')
     if (typeof collection !== 'string') throw Error('Signal.query() expects collection to be a string')
     const normalized = normalizeQueryParams(collection, params)
+    const root = getRoot(this) || (this[ROOT_ID] ? this : undefined)
+    const scopedOptions = withQueryScopeOptions(options, root)
     if (isAggregationParams(normalized)) {
-      return getAggregationSignal(collection, normalized, options)
+      return getAggregationSignal(collection, normalized, scopedOptions)
     }
-    return getQuerySignal(collection, normalized, options)
+    return getQuerySignal(collection, normalized, scopedOptions)
   }
 
   subscribe (...items) {
@@ -140,9 +146,15 @@ class SignalCompat extends Signal {
     if (callback != null && typeof callback !== 'function') {
       throw Error('Signal.close() expects callback to be a function')
     }
-    // Compatibility shim for legacy `model.close()` calls.
-    // Teamplay uses a global root signal and does not have per-model instances to dispose.
-    if (callback) callback()
+    const $root = getRoot(this) || this
+    const rootId = $root?.[ROOT_ID]
+    unregisterRootFinalizer($root)
+    disposeRootContext(rootId)
+      .then(() => callback?.())
+      .catch(err => {
+        if (callback) callback(err)
+        else console.error(err)
+      })
   }
 
   silent (value) {
@@ -542,7 +554,8 @@ class SignalCompat extends Signal {
       }
       if (typeof handler !== 'function') throw Error('Signal.on() expects a handler function')
       const normalized = normalizePattern(pattern, 'Signal.on()')
-      return onModelEvent(eventName, normalized, handler)
+      const rootId = (getRoot(this) || this)?.[ROOT_ID]
+      return onModelEvent(rootId, eventName, normalized, handler)
     }
     if (typeof pattern !== 'function') throw Error('Signal.on() expects a handler function')
     return onCustomEvent(eventName, pattern)
@@ -572,7 +585,8 @@ class SignalCompat extends Signal {
   removeListener (eventName, handler) {
     if (arguments.length !== 2) throw Error('Signal.removeListener() expects two arguments')
     if (eventName === 'change' || eventName === 'all') {
-      return removeModelListener(eventName, handler)
+      const rootId = (getRoot(this) || this)?.[ROOT_ID]
+      return removeModelListener(rootId, eventName, handler)
     }
     return removeCustomEventListener(eventName, handler)
   }
@@ -606,13 +620,21 @@ class SignalCompat extends Signal {
     const mirrorOnly = !!($to?.[IS_QUERY] || $to?.[IS_AGGREGATION])
     const { stop, onChange } = createRefLink($from, $to, { mirrorOnly, options })
     store.set(fromPath, { stop })
+    const fromRootId = (getRoot($from) || $from)?.[ROOT_ID]
+    const toRootId = (getRoot($to) || $to)?.[ROOT_ID]
     if (!mirrorOnly) {
       $from[REF_TARGET] = $to
-      setRefLink(fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], { mirrorOnly: false })
+      setRefLink(fromRootId, fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], {
+        mirrorOnly: false,
+        fromRootId,
+        toRootId
+      })
     } else {
-      setRefLink(fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], {
+      setRefLink(fromRootId, fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], {
         mirrorOnly: true,
-        onChange
+        onChange,
+        fromRootId,
+        toRootId
       })
       if ($from[REF_TARGET]) delete $from[REF_TARGET]
     }
@@ -658,7 +680,8 @@ class SignalCompat extends Signal {
       existing.stop()
       store.delete(fromPath)
     }
-    removeRefLink(fromPath)
+    const fromRootId = (getRoot($from) || $from)?.[ROOT_ID]
+    removeRefLink(fromRootId, fromPath)
     const $target = resolveRefSignal($from)
     if ($target !== $from) {
       setDiffDeepBypassRef($from, deepCopy($target.get()))
@@ -725,11 +748,10 @@ function createSilentSignalWrapper ($signal, enabled = true) {
   return new Proxy($signal, handler)
 }
 
-const REFS = Symbol('compat refs')
 function getRefStore ($signal) {
   const $root = getRoot($signal) || $signal
-  $root[REFS] ??= new Map()
-  return $root[REFS]
+  const rootId = $root?.[ROOT_ID]
+  return getRootContext(rootId, true).activeRefs
 }
 
 function createRefLink ($from, $to, { mirrorOnly = false } = {}) {
@@ -790,7 +812,10 @@ function readRefValue ($signal) {
 function resolveRefSignal ($signal) {
   const directTarget = resolveRefSignalSafe($signal)
   if (directTarget && directTarget !== $signal) return directTarget
-  const resolvedSegments = resolveRefSegmentsSafe($signal[SEGMENTS])
+  const resolvedSegments = resolveRefSegmentsSafe(
+    $signal[SEGMENTS],
+    (getRoot($signal) || $signal)?.[ROOT_ID]
+  )
   if (!resolvedSegments) return $signal
   const $root = getRoot($signal) || $signal
   return resolveSignal($root, resolvedSegments)
@@ -805,21 +830,28 @@ function forwardRef ($signal, methodName, args) {
 function setDiffDeepBypassRef ($signal, value) {
   const segments = $signal[SEGMENTS]
   if (isPublicCollection(segments[0])) return Signal.prototype.set.call($signal, value)
-  return _setReplace(segments, value)
+  return setReplacePrivateData(getOwningRootId($signal), segments, value)
 }
 
 function mirrorRefMutationFromTarget (targetSegments, value) {
   if (!Array.isArray(targetSegments) || targetSegments.length === 0) return
   const updates = []
-  for (const link of getRefLinks().values()) {
+  for (const link of getAllRefLinks()) {
     if (!isPathPrefix(link.toSegments, targetSegments)) continue
     const suffix = targetSegments.slice(link.toSegments.length)
-    updates.push({ segments: link.fromSegments.concat(suffix), value: deepCopy(value) })
+    updates.push({
+      fromRootId: link.fromRootId,
+      segments: link.fromSegments.concat(suffix),
+      value: deepCopy(value)
+    })
   }
   if (!updates.length) return
-  const $root = getRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ })
   runInModelEventsSilentContext(() => {
     for (const update of updates) {
+      const $root = getRootSignal({
+        rootId: update.fromRootId || GLOBAL_ROOT_ID,
+        rootFunction: universal$
+      })
       const $target = resolveSignal($root, update.segments)
       setDiffDeepBypassRef($target, update.value)
     }
@@ -891,7 +923,10 @@ function resolveSignal ($signal, segments) {
 function resolveSignalWithRefs ($signal, relativeSegments) {
   const baseSegments = Array.isArray($signal?.[SEGMENTS]) ? $signal[SEGMENTS] : []
   const absoluteSegments = baseSegments.concat(relativeSegments)
-  const resolvedSegments = resolveRefSegmentsSafe(absoluteSegments)
+  const resolvedSegments = resolveRefSegmentsSafe(
+    absoluteSegments,
+    (getRoot($signal) || $signal)?.[ROOT_ID]
+  )
   if (!resolvedSegments) return resolveSignal($signal, relativeSegments)
 
   // Signals created through root functions can carry a raw root in [ROOT].
@@ -1018,7 +1053,7 @@ function setReplacePrivateCompatSync ($signal, value) {
   if (isPublicDocPath(segments)) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
-  _setReplace(segments, value)
+  setReplacePrivateData(getOwningRootId($signal), segments, value)
   mirrorRefMutationFromTarget(segments, value)
 }
 
@@ -1027,7 +1062,7 @@ function delPrivateCompatSync ($signal) {
   if (segments.length === 0) throw Error('Can\'t delete the root signal data')
   const idFields = getIdFieldsForSegments(segments)
   if (isIdFieldPath(segments, idFields)) return
-  _del(segments)
+  delPrivateData(getOwningRootId($signal), segments)
 }
 
 function deepEqualCompat (left, right) {
@@ -1074,7 +1109,7 @@ async function setReplaceOnSignal ($signal, value) {
     return result
   }
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  const result = _setReplace(segments, value)
+  const result = setReplacePrivateData(getOwningRootId($signal), segments, value)
   mirrorRefMutationFromTarget(segments, value)
   return result
 }
@@ -1094,7 +1129,7 @@ async function incrementOnSignal ($signal, byNumber) {
     return currentValue + byNumber
   }
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  _setReplace(segments, currentValue + byNumber)
+  setReplacePrivateData(getOwningRootId($signal), segments, currentValue + byNumber)
   return currentValue + byNumber
 }
 
@@ -1127,7 +1162,7 @@ async function arrayPushOnSignal ($signal, value) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayPushPublic(segments, value)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayPush(segments, value)
+  return arrayPushPrivateData(getOwningRootId($signal), segments, value)
 }
 
 async function arrayUnshiftOnSignal ($signal, value) {
@@ -1136,7 +1171,7 @@ async function arrayUnshiftOnSignal ($signal, value) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayUnshiftPublic(segments, value)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayUnshift(segments, value)
+  return arrayUnshiftPrivateData(getOwningRootId($signal), segments, value)
 }
 
 async function arrayInsertOnSignal ($signal, index, values) {
@@ -1145,7 +1180,7 @@ async function arrayInsertOnSignal ($signal, index, values) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayInsertPublic(segments, index, values)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayInsert(segments, index, values)
+  return arrayInsertPrivateData(getOwningRootId($signal), segments, index, values)
 }
 
 async function arrayPopOnSignal ($signal) {
@@ -1154,7 +1189,7 @@ async function arrayPopOnSignal ($signal) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayPopPublic(segments)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayPop(segments)
+  return arrayPopPrivateData(getOwningRootId($signal), segments)
 }
 
 async function arrayShiftOnSignal ($signal) {
@@ -1163,7 +1198,7 @@ async function arrayShiftOnSignal ($signal) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayShiftPublic(segments)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayShift(segments)
+  return arrayShiftPrivateData(getOwningRootId($signal), segments)
 }
 
 async function arrayRemoveOnSignal ($signal, index, howMany) {
@@ -1172,7 +1207,7 @@ async function arrayRemoveOnSignal ($signal, index, howMany) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayRemovePublic(segments, index, howMany)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayRemove(segments, index, howMany)
+  return arrayRemovePrivateData(getOwningRootId($signal), segments, index, howMany)
 }
 
 async function arrayMoveOnSignal ($signal, from, to, howMany) {
@@ -1181,7 +1216,7 @@ async function arrayMoveOnSignal ($signal, from, to, howMany) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _arrayMovePublic(segments, from, to, howMany)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _arrayMove(segments, from, to, howMany)
+  return arrayMovePrivateData(getOwningRootId($signal), segments, from, to, howMany)
 }
 
 async function stringInsertOnSignal ($signal, index, text) {
@@ -1190,7 +1225,7 @@ async function stringInsertOnSignal ($signal, index, text) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _stringInsertPublic(segments, index, text)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _stringInsertLocal(segments, index, text)
+  return stringInsertPrivateData(getOwningRootId($signal), segments, index, text)
 }
 
 async function stringRemoveOnSignal ($signal, index, howMany) {
@@ -1199,7 +1234,12 @@ async function stringRemoveOnSignal ($signal, index, howMany) {
   if (isIdFieldPath(segments, idFields)) return
   if (isPublicCollection(segments[0])) return _stringRemovePublic(segments, index, howMany)
   if (publicOnly) throw Error(ERRORS.publicOnly)
-  return _stringRemoveLocal(segments, index, howMany)
+  return stringRemovePrivateData(getOwningRootId($signal), segments, index, howMany)
+}
+
+function getOwningRootId ($signal) {
+  const $root = getRoot($signal) || $signal
+  return $root?.[ROOT_ID]
 }
 
 function shallowCopy (value) {
@@ -1246,6 +1286,17 @@ function isAggregationParams (params) {
   return Boolean(params?.$aggregate || params?.$aggregationName)
 }
 
+function withQueryScopeOptions (options, $root) {
+  if (!options || typeof options !== 'object') {
+    if (!$root) return options
+    return { root: $root }
+  }
+
+  const nextOptions = { ...options }
+  if (nextOptions.root == null && $root) nextOptions.root = $root
+  return nextOptions
+}
+
 function withFetchOnly (fn) {
   const prevFetchOnly = fetchOnly
   setFetchOnly(true)

package/orm/Compat/eventsCompat.js

@@ -54,9 +54,9 @@ export function useOn (eventName, patternOrHandler, handler, deps) {
       return
     }
     if (!isModelEventsEnabled()) return
-    const listener = onModelEvent(eventName, normalizedPattern, handler)
+    const listener = onModelEvent(undefined, eventName, normalizedPattern, handler)
     return () => {
-      removeModelListener(eventName, listener)
+      removeModelListener(undefined, eventName, listener)
     }
   }, [eventName, patternOrHandler, handler, deps, normalizedPattern, isCustom])
 }

package/orm/Compat/modelEvents.js

@@ -1,11 +1,10 @@
-import { getRefLinks } from './refRegistry.js'
+import { getRefLinks, getRefRootIds } from './refRegistry.js'
 import { isCompatEnv } from '../compatEnv.js'
 import { isSilentContextActive, isModelEventsSilentContextActive } from './silentContext.js'
+import { normalizeRootId } from '../rootScope.js'
+import { getRootContext, getRootContexts } from '../rootContext.js'
 
-const modelListeners = {
-  change: new Map(),
-  all: new Map()
-}
+const MODEL_EVENT_NAMES = ['change', 'all']
 
 export function isModelEventsEnabled () {
   return isCompatEnv()
@@ -20,10 +19,10 @@ export function normalizePattern (pattern, methodName) {
   return pattern.split('.').filter(Boolean).join('.')
 }
 
-export function onModelEvent (eventName, pattern, handler) {
+export function onModelEvent (rootId, eventName, pattern, handler) {
   if (typeof handler !== 'function') throw Error('Model event handler must be a function')
-  if (!modelListeners[eventName]) throw Error(`Unsupported model event: ${eventName}`)
-  const store = modelListeners[eventName]
+  if (!MODEL_EVENT_NAMES.includes(eventName)) throw Error(`Unsupported model event: ${eventName}`)
+  const store = getModelEventRootStore(eventName, rootId, true)
   const normalized = normalizePattern(pattern)
   let entry = store.get(normalized)
   if (!entry) {
@@ -38,8 +37,8 @@ export function onModelEvent (eventName, pattern, handler) {
   return handler
 }
 
-export function removeModelListener (eventName, handler) {
-  const store = modelListeners[eventName]
+export function removeModelListener (rootId, eventName, handler) {
+  const store = getModelEventRootStore(eventName, rootId)
   if (!store) return
   for (const [pattern, entry] of store) {
     entry.handlers.delete(handler)
@@ -51,39 +50,44 @@ export function emitModelChange (path, value, prevValue, meta) {
   if (!isModelEventsEnabled()) return
   if (isSilentContextActive() || isModelEventsSilentContextActive()) return
   const initialSegments = splitPath(path)
-  const visited = new Set()
-  const queue = [initialSegments]
   const eventName = meta?.eventName || 'change'
+  const rootIds = getTargetRootIds(meta?.rootId)
+
+  for (const rootId of rootIds) {
+    const visited = new Set()
+    const queue = [initialSegments]
 
-  while (queue.length) {
-    const segments = queue.shift()
-    const key = segments.join('.')
-    if (visited.has(key)) continue
-    visited.add(key)
+    while (queue.length) {
+      const segments = queue.shift()
+      const key = segments.join('.')
+      if (visited.has(key)) continue
+      visited.add(key)
 
-    emitForEvent('change', segments, value, prevValue, meta)
-    emitForEvent('all', segments, value, prevValue, meta, eventName)
+      emitForEvent(rootId, 'change', segments, value, prevValue, meta)
+      emitForEvent(rootId, 'all', segments, value, prevValue, meta, eventName)
 
-    for (const link of getRefLinks().values()) {
-      if (!isPathPrefix(link.toSegments, segments)) continue
-      if (link.mirrorOnly && typeof link.onChange === 'function') {
-        link.onChange()
+      for (const link of getRefLinks(rootId).values()) {
+        if (!isPathPrefix(link.toSegments, segments)) continue
+        if (link.mirrorOnly && typeof link.onChange === 'function') {
+          link.onChange()
+        }
+        const suffix = segments.slice(link.toSegments.length)
+        const nextSegments = link.fromSegments.concat(suffix)
+        const nextKey = nextSegments.join('.')
+        if (!visited.has(nextKey)) queue.push(nextSegments)
       }
-      const suffix = segments.slice(link.toSegments.length)
-      const nextSegments = link.fromSegments.concat(suffix)
-      const nextKey = nextSegments.join('.')
-      if (!visited.has(nextKey)) queue.push(nextSegments)
     }
   }
 }
 
 export function __resetModelEventsForTests () {
-  modelListeners.change.clear()
-  modelListeners.all.clear()
+  for (const context of getRootContexts()) {
+    context.resetModelListeners()
+  }
 }
 
-function emitForEvent (eventName, pathSegments, value, prevValue, meta, resolvedEventName = eventName) {
-  const store = modelListeners[eventName]
+function emitForEvent (rootId, eventName, pathSegments, value, prevValue, meta, resolvedEventName = eventName) {
+  const store = getModelEventRootStore(eventName, rootId)
   if (!store || store.size === 0) return
   for (const entry of store.values()) {
     const captures = matchPattern(entry.segments, pathSegments)
@@ -103,6 +107,29 @@ function splitPattern (pattern) {
   return pattern.split('.').filter(Boolean)
 }
 
+function getModelEventRootStore (eventName, rootId, create = false) {
+  return getRootContext(normalizeRootId(rootId), create)?.getModelEventStore(eventName, create)
+}
+
+function getModelEventRootIds () {
+  const rootIds = new Set()
+  for (const context of getRootContexts()) {
+    for (const store of Object.values(context.modelListeners)) {
+      if (store.size) rootIds.add(context.rootId)
+    }
+  }
+  return rootIds
+}
+
+function getTargetRootIds (rootId) {
+  if (rootId != null) return [normalizeRootId(rootId)]
+  const rootIds = new Set([
+    ...getModelEventRootIds(),
+    ...getRefRootIds()
+  ])
+  return rootIds
+}
+
 function splitPath (path) {
   if (Array.isArray(path)) return path.map(segment => String(segment))
   if (!path) return []