teamplay 0.4.0-alpha.96 → 0.4.0-alpha.98

package/orm/Compat/README.md

@@ -119,6 +119,10 @@ 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.
 
+Source path restriction:
+- The ref source path (`$from`) must be in a private collection (`_session`, `_page`, `$local`, etc.).
+- Public source paths are not supported.
+
 ```js
 const $local = $.local.value
 const $user = $.users.user1
@@ -201,7 +205,6 @@ $table.dataSource.get()
 
 **Limitations vs Racer**
 - No `refList`, `refMap`.
-- No automatic list index patching on insert/remove/move.
 - No event emissions specific to refs.
 - No support for racer-style ref meta/options beyond the basic signature.
 

package/orm/Compat/SignalCompat.js

@@ -29,11 +29,11 @@ import {
 } 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 { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener } from './modelEvents.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 { runInSilentContext, runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js'
 import universal$ from '../../react/universal$.js'
 import { getRootContext } from '../rootContext.js'
 import disposeRootContext from '../disposeRootContext.js'
@@ -618,6 +618,7 @@ class SignalCompat extends Signal {
     }
     if (!$to) throw Error('Signal.ref() expects a target path or signal')
     if ($from === $to) return $from
+    ensurePrivateRefSource($from, 'Signal.ref()')
     const store = getRefStore($from)
     const fromPath = $from.path()
     const existing = store.get(fromPath)
@@ -1060,7 +1061,9 @@ function setReplacePrivateCompatSync ($signal, value) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
   setReplacePrivateData(getOwningRootId($signal), segments, value)
-  mirrorRefMutationFromTarget(segments, value)
+  if (shouldMirrorPrivateRefMutationLocally()) {
+    mirrorRefMutationFromTarget(segments, value)
+  }
 }
 
 function delPrivateCompatSync ($signal, options) {
@@ -1115,12 +1118,16 @@ async function setReplaceOnSignal ($signal, value) {
   }
   if (isPublicCollection(segments[0])) {
     const result = await _setPublicDocReplace(segments, value)
-    mirrorRefMutationFromTarget(segments, value)
+    if (shouldMirrorPublicRefMutationLocally(segments)) {
+      mirrorRefMutationFromTarget(segments, value)
+    }
     return result
   }
   if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
   const result = setReplacePrivateData(getOwningRootId($signal), segments, value)
-  mirrorRefMutationFromTarget(segments, value)
+  if (shouldMirrorPrivateRefMutationLocally()) {
+    mirrorRefMutationFromTarget(segments, value)
+  }
   return result
 }
 
@@ -1252,6 +1259,27 @@ function getOwningRootId ($signal) {
   return $root?.[ROOT_ID]
 }
 
+function ensurePrivateRefSource ($signal, methodName) {
+  const segments = $signal?.[SEGMENTS]
+  const collection = segments?.[0]
+  if (typeof collection === 'string' && /^[_$]/.test(collection)) return
+  throw Error(`${methodName} source path must be in a private collection`)
+}
+
+function shouldMirrorPublicRefMutationLocally (segments) {
+  if (isSilentContextActive()) return true
+  if (!Array.isArray(segments) || segments.length < 2) return true
+  // Public doc ops emit compat model events only when there is an initialized
+  // Doc runtime (subscribed/fetched). Without runtime we must mirror immediately.
+  const transportHash = JSON.stringify([segments[0], segments[1]])
+  return !docSubscriptions.hasRuntime(transportHash)
+}
+
+function shouldMirrorPrivateRefMutationLocally () {
+  if (isSilentContextActive()) return true
+  return !isModelEventsEnabled()
+}
+
 function shallowCopy (value) {
   const rawValue = raw(value)
   if (Array.isArray(rawValue)) return rawValue.slice()

package/orm/Compat/modelEvents.js

@@ -1,8 +1,10 @@
 import { getRefLinks, getRefRootIds } from './refRegistry.js'
 import { isCompatEnv } from '../compatEnv.js'
-import { isSilentContextActive, isModelEventsSilentContextActive } from './silentContext.js'
+import { isSilentContextActive, isModelEventsSilentContextActive, runInModelEventsSilentContext } from './silentContext.js'
 import { normalizeRootId } from '../rootScope.js'
 import { getRootContext, getRootContexts } from '../rootContext.js'
+import { setReplace as setReplaceInDataTree, del as delFromDataTree } from '../dataTree.js'
+import { setReplacePrivateData, delPrivateData } from '../privateData.js'
 
 const MODEL_EVENT_NAMES = ['change', 'all']
 
@@ -70,6 +72,8 @@ export function emitModelChange (path, value, prevValue, meta) {
         if (!isPathPrefix(link.toSegments, segments)) continue
         if (link.mirrorOnly && typeof link.onChange === 'function') {
           link.onChange()
+        } else if (!link.mirrorOnly) {
+          mirrorRefAliasFromTargetSegments(rootId, link, segments, value, meta)
         }
         const suffix = segments.slice(link.toSegments.length)
         const nextSegments = link.fromSegments.concat(suffix)
@@ -107,6 +111,49 @@ function splitPattern (pattern) {
   return pattern.split('.').filter(Boolean)
 }
 
+function mirrorRefAliasFromTargetSegments (rootId, link, targetSegments, value, meta) {
+  const suffix = targetSegments.slice(link.toSegments.length)
+  const fromSegments = link.fromSegments.concat(suffix)
+  const fromRootId = normalizeRootId(link.fromRootId ?? rootId)
+  const shouldDelete = shouldDeleteMirroredPath(value, meta)
+  runInModelEventsSilentContext(() => {
+    if (isPrivateSegments(fromSegments)) {
+      if (shouldDelete) {
+        delPrivateData(fromRootId, fromSegments)
+      } else {
+        setReplacePrivateData(fromRootId, fromSegments, cloneValue(value))
+      }
+      return
+    }
+    if (shouldDelete) {
+      delFromDataTree(fromSegments)
+      return
+    }
+    setReplaceInDataTree(fromSegments, cloneValue(value))
+  })
+}
+
+function isPrivateSegments (segments) {
+  if (!Array.isArray(segments) || !segments.length) return false
+  return /^[_$]/.test(String(segments[0]))
+}
+
+function shouldDeleteMirroredPath (value, meta) {
+  if (meta?.op === 'setReplace') return false
+  if (meta?.op === 'del') return true
+  return value === undefined
+}
+
+function cloneValue (value) {
+  if (Array.isArray(value)) return value.map(cloneValue)
+  if (value && typeof value === 'object') {
+    const cloned = {}
+    for (const key of Object.keys(value)) cloned[key] = cloneValue(value[key])
+    return cloned
+  }
+  return value
+}
+
 function getModelEventRootStore (eventName, rootId, create = false) {
   return getRootContext(normalizeRootId(rootId), create)?.getModelEventStore(eventName, create)
 }

package/orm/dataTree.js

@@ -326,6 +326,13 @@ export async function setPublicDocReplace (segments, value) {
   }
 
   const relativePath = segments.slice(2)
+  // json0 direct replace ops require every ancestor container to already exist.
+  // Racer-like compat set, however, materializes missing/primitive parents while
+  // descending into the path. Fall back to the older diff-based path when the
+  // direct op would target a non-existent/non-object ancestor.
+  if (!canApplyDirectReplaceOp(docState.snapshot || {}, relativePath)) {
+    return setPublicDoc(segments, value)
+  }
   const previous = getRaw(segments)
   const normalizedPrevious = normalizeUndefined(
     relativePath.length === 0 ? stripIdFields(previous, idFields) : previous
@@ -444,6 +451,16 @@ function normalizeUndefined (value) {
   return value === undefined ? null : value
 }
 
+function canApplyDirectReplaceOp (docSnapshot, relativePath) {
+  if (relativePath.length === 0) return true
+  let node = docSnapshot
+  for (let i = 0; i < relativePath.length - 1; i++) {
+    if (node == null || typeof node !== 'object') return false
+    node = node[relativePath[i]]
+  }
+  return node != null && typeof node === 'object'
+}
+
 function normalizeValueForOp (value) {
   let result = raw(value)
   if (result != null && typeof result === 'object') result = JSON.parse(JSON.stringify(result))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.96",
+  "version": "0.4.0-alpha.98",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "78f33dc002740b425f3a056fad5b7e780a34219c"
+  "gitHead": "ae4e0e6ee39e395fa9eb48a2099cc1d5b2a4630d"
 }

package/react/useSub.js

@@ -44,8 +44,8 @@ export function useSubDeferred (signal, params, { async = false, defer, batch =
   // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
   if (promiseOrSignal.then) {
     const promise = maybeThrottle(promiseOrSignal)
+    const hasPreviousSignal = !!$signalRef.current
     if (batch) {
-      const hasPreviousSignal = !!$signalRef.current
       // Batch suspense must block only on initial load.
       // On resubscribe we keep rendering previous signal and refresh in background.
       if (!hasPreviousSignal) {
@@ -61,6 +61,11 @@ export function useSubDeferred (signal, params, { async = false, defer, batch =
       scheduleUpdate(promise)
       return
     }
+    // Keep previous snapshot during update re-subscribe and refresh in background.
+    if (hasPreviousSignal) {
+      scheduleUpdate(promise)
+      return $signalRef.current
+    }
     if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
     throw promise
   // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists