teamplay 0.4.0-alpha.30 → 0.4.0-alpha.32

package/orm/Compat/README.md

@@ -116,6 +116,8 @@ $.users.user1.scope('users', 'user2')
 Creates a lightweight alias between signals (minimal Racer-style ref).
 Mutations on the alias are forwarded to the target. The alias mirrors target updates.
 Reads (`get`/`peek`) are forwarded to the target while the ref is active.
+Ref mirroring is scheduled through Teamplay runtime scheduler, so updates remain batch-friendly
+and do not leak intermediate ref states during a single batched cycle.
 
 ```js
 const $local = $.local.value
@@ -199,7 +201,8 @@ $root.start('_virtual.lesson', $.lessons[lessonId], '_session.userId', (lesson,
 
 Behavior:
 - Calling `start()` again for the same `targetPath` replaces previous reaction.
-- `undefined` / `null` result clears target path via normal `set` semantics.
+- `undefined` result applies compat delete semantics at target path.
+- `null` result is stored as `null`.
 - Returns target signal.
 - If any dependency temporarily suspends (throws a Promise/thenable), compat skips the whole tick (getter is not called and target is not written).
 - If `getter` throws a Promise, compat skips that tick and retries on next reactive update.
@@ -365,6 +368,7 @@ Compatibility mode intentionally aligns mutators with Racer. This differs from c
 | `setDiff` | N/A as compat shim. | Alias to compat `set` for both signatures: `setDiff(value)` and `setDiff(path, value)`. |
 
 Migration note: compat behavior is intentionally Racer-aligned and may differ from core mutators.
+Composite compat mutators (`setEach`, `setDiffDeep`) apply updates atomically for Teamplay-scheduled observers via the runtime batch scheduler.
 
 ### set(value) and set(path, value)
 

package/orm/Compat/SignalCompat.js

@@ -40,6 +40,7 @@ import { on as onCustomEvent, removeListener as removeCustomEventListener } from
 import { normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js'
 import { setRefLink, removeRefLink } from './refRegistry.js'
 import { REF_TARGET, resolveRefSignalSafe } from './refFallback.js'
+import { runInBatch, scheduleReaction } from '../batchScheduler.js'
 
 class SignalCompat extends Signal {
   static ID_FIELDS = ['_id', 'id']
@@ -225,7 +226,7 @@ class SignalCompat extends Signal {
       value = path
     }
     const $target = resolveSignal(this, segments)
-    return setDiffDeepOnSignal($target, value)
+    return runInBatch(() => setDiffDeepOnSignal($target, value))
   }
 
   async setDiff (path, value) {
@@ -253,11 +254,13 @@ class SignalCompat extends Signal {
     if (typeof object !== 'object') {
       throw Error('Signal.setEach() expects an object argument, got: ' + typeof object)
     }
-    const promises = []
-    for (const key of Object.keys(object)) {
-      promises.push(SignalCompat.prototype.set.call($target[key], object[key]))
-    }
-    await Promise.all(promises)
+    return runInBatch(async () => {
+      const promises = []
+      for (const key of Object.keys(object)) {
+        promises.push(SignalCompat.prototype.set.call($target[key], object[key]))
+      }
+      await Promise.all(promises)
+    })
   }
 
   async del (path) {
@@ -574,6 +577,7 @@ class SignalCompat extends Signal {
 }
 
 const REFS = Symbol('compat refs')
+const SKIP_REF_TICK = Symbol('compat ref skip tick')
 
 function getRefStore ($signal) {
   const $root = getRoot($signal) || $signal
@@ -583,15 +587,25 @@ function getRefStore ($signal) {
 
 function createRefLink ($from, $to) {
   const toReaction = observe(() => {
-    const value = $to.get()
+    const value = readRefValue($to)
+    if (value === SKIP_REF_TICK) return
     trackDeep(value)
     setDiffDeepBypassRef($from, deepCopy(value))
-  })
+  }, { scheduler: scheduleReaction })
   return () => {
     unobserve(toReaction)
   }
 }
 
+function readRefValue ($signal) {
+  try {
+    return $signal.get()
+  } catch (err) {
+    if (isThenable(err)) return SKIP_REF_TICK
+    throw err
+  }
+}
+
 function trackDeep (value, seen = new Set()) {
   if (!value || typeof value !== 'object') return
   if (seen.has(value)) return
@@ -629,6 +643,10 @@ function isReactLike (value) {
   return !!(value && typeof value === 'object' && typeof value.$$typeof === 'symbol')
 }
 
+function isThenable (value) {
+  return !!value && typeof value.then === 'function'
+}
+
 function resolveRefTarget ($signal, target, methodName) {
   if (isSignalLike(target)) return target
   if (typeof target === 'string') {

package/orm/Compat/startStopCompat.js

@@ -1,5 +1,6 @@
 import { observe, unobserve } from '@nx-js/observer-util'
 import { getRoot } from '../Root.js'
+import { scheduleReaction } from '../batchScheduler.js'
 
 const START_REACTIONS = Symbol('compat start reactions')
 const SKIP_TICK = Symbol('compat start skip tick')
@@ -39,7 +40,7 @@ export function compatStartOnRoot ($root, targetPath, ...depsAndGetter) {
     }
     const maybePromise = $target.set(nextValue)
     if (maybePromise?.catch) maybePromise.catch(ignorePromiseRejection)
-  })
+  }, { scheduler: scheduleReaction })
   store.set(targetKey, { stop: () => unobserve(reaction) })
   return $target
 }

package/orm/Reaction.js

@@ -3,6 +3,7 @@ import { SEGMENTS } from './Signal.js'
 import { set as _set, del as _del } from './dataTree.js'
 import { LOCAL } from './Value.js'
 import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import { scheduleReaction } from './batchScheduler.js'
 
 // this is `let` to be able to directly change it if needed in tests or in the app
 export let DELETION_DELAY = 0 // eslint-disable-line prefer-const
@@ -18,7 +19,7 @@ class ReactionSubscriptions {
     if (this.initialized.has(id)) return
 
     this.initialized.set(id, true)
-    const reactionScheduler = reaction => runReaction(id, reaction)
+    const reactionScheduler = reaction => scheduleReaction(() => runReaction(id, reaction))
     const reaction = observe(fn, { lazy: true, scheduler: reactionScheduler })
     this.fr.register($value, [id, reaction])
     runReaction(id, reaction)

package/orm/SignalBase.js

@@ -49,6 +49,7 @@ import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, normalizeIdFi
 import { isCompatEnv } from './compatEnv.js'
 import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js'
 import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js'
+import { runInBatch } from './batchScheduler.js'
 
 export const SEGMENTS = Symbol('path segments targeting the particular node in the data tree')
 export const ARRAY_METHOD = Symbol('run array method on the signal')
@@ -105,7 +106,7 @@ export class Signal extends Function {
     if (arguments.length > 1) throw Error('Signal.batch() expects a single argument')
     if (fn == null) return
     if (typeof fn !== 'function') throw Error('Signal.batch() expects a function argument')
-    return fn()
+    return runInBatch(fn)
   }
 
   [GET] (method) {

package/orm/batchScheduler.js

@@ -0,0 +1,62 @@
+let batchDepth = 0
+let isFlushing = false
+const queuedReactions = new Set()
+
+export function beginBatch () {
+  batchDepth += 1
+}
+
+export function endBatch () {
+  if (batchDepth === 0) return
+  batchDepth -= 1
+  if (batchDepth === 0) flushReactions()
+}
+
+export function inBatch () {
+  return batchDepth > 0
+}
+
+export function runInBatch (fn) {
+  beginBatch()
+  let result
+  try {
+    result = fn()
+  } catch (err) {
+    endBatch()
+    throw err
+  }
+  if (result?.then) {
+    return Promise.resolve(result).finally(endBatch)
+  }
+  endBatch()
+  return result
+}
+
+export function scheduleReaction (reactionFn) {
+  if (typeof reactionFn !== 'function') return
+  if (inBatch() || isFlushing) {
+    queuedReactions.add(reactionFn)
+    return
+  }
+  reactionFn()
+}
+
+export function flushReactions () {
+  if (isFlushing) return
+  isFlushing = true
+  try {
+    while (queuedReactions.size > 0) {
+      const queue = Array.from(queuedReactions)
+      queuedReactions.clear()
+      for (const reactionFn of queue) reactionFn()
+    }
+  } finally {
+    isFlushing = false
+  }
+}
+
+export function __resetBatchSchedulerForTests () {
+  batchDepth = 0
+  isFlushing = false
+  queuedReactions.clear()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.30",
+  "version": "0.4.0-alpha.32",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -81,5 +81,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "dc30b21a5d5d2cf5dc0e9ad96ff61fc7fcd8930c"
+  "gitHead": "384c14383a45af21bad2f752011db1462f7d8628"
 }

package/react/convertToObserver.js

@@ -6,6 +6,7 @@ import { __increment, __decrement } from '@teamplay/debug'
 import executionContextTracker from './executionContextTracker.js'
 import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from './helpers.js'
 import trapRender from './trapRender.js'
+import { scheduleReaction } from '../orm/batchScheduler.js'
 
 const DEFAULT_THROTTLE_TIMEOUT = 100
 
@@ -52,7 +53,7 @@ export default function convertToObserver (BaseComponent, {
         componentId
       })
       reactionRef.current = observe(trappedRender, {
-        scheduler: update,
+        scheduler: () => scheduleReaction(update),
         lazy: true
       })
     }