teamplay 0.4.0-alpha.95 → 0.4.0-alpha.97

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

@@ -33,7 +33,7 @@ import { normalizePattern, onModelEvent, removeModelListener } from './modelEven
 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,7 @@ function setReplacePrivateCompatSync ($signal, value) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
   setReplacePrivateData(getOwningRootId($signal), segments, value)
-  mirrorRefMutationFromTarget(segments, value)
+  if (isSilentContextActive()) mirrorRefMutationFromTarget(segments, value)
 }
 
 function delPrivateCompatSync ($signal, options) {
@@ -1115,12 +1116,14 @@ 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 (isSilentContextActive()) mirrorRefMutationFromTarget(segments, value)
   return result
 }
 
@@ -1252,6 +1255,22 @@ 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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.95",
+  "version": "0.4.0-alpha.97",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "43c734951b848a2da50848e9930e50cdf7fdd9d1"
+  "gitHead": "633e39dc754332bcd3d95ddc4cfb3522f0bfd694"
 }

package/react/renderAttemptDestroyer.js

@@ -1,37 +1,46 @@
 class RenderAttemptDestroyer {
   constructor () {
     this.fns = []
-    this.compatArmed = false
+    this.compatAttemptCleanupArmed = false
+    this.suspenseGateArmed = false
   }
 
   add (fn, { compat = false } = {}) {
     if (typeof fn !== 'function') return
     this.fns.push(fn)
-    if (compat) this.compatArmed = true
+    if (compat) this.compatAttemptCleanupArmed = true
   }
 
-  armCompat () {
-    this.compatArmed = true
+  armCompatAttemptCleanup () {
+    this.compatAttemptCleanupArmed = true
   }
 
-  getDestructor () {
-    if (!this.compatArmed) {
-      this.reset()
-      return undefined
-    }
+  armSuspenseGate () {
+    this.suspenseGateArmed = true
+  }
 
-    const fns = [...this.fns]
+  consumeThenableHandling () {
+    const shouldRunAttemptCleanup = this.compatAttemptCleanupArmed && this.fns.length > 0
+    const shouldKeepShellAlive = this.suspenseGateArmed || shouldRunAttemptCleanup
+    let destroyAttempt
+    if (shouldRunAttemptCleanup) {
+      const fns = [...this.fns]
+      destroyAttempt = async () => {
+        await Promise.allSettled(fns.map(fn => fn()))
+        fns.length = 0
+      }
+    }
     this.reset()
-    return async () => {
-      if (fns.length === 0) return
-      await Promise.allSettled(fns.map(fn => fn()))
-      fns.length = 0
+    return {
+      shouldKeepShellAlive,
+      destroyAttempt
     }
   }
 
   reset () {
     this.fns.length = 0
-    this.compatArmed = false
+    this.compatAttemptCleanupArmed = false
+    this.suspenseGateArmed = false
   }
 }
 

package/react/trapRender.js

@@ -24,8 +24,11 @@ export default function trapRender ({ render, cache, destroy, componentId }) {
         destroyed = true
         throw err
       }
-      const destroyAttempt = renderAttemptDestroyer.getDestructor()
-      if (destroyAttempt) {
+      const {
+        shouldKeepShellAlive,
+        destroyAttempt
+      } = renderAttemptDestroyer.consumeThenableHandling()
+      if (shouldKeepShellAlive) {
         throw Promise.resolve(err).then(() => destroyAttempt?.())
       }
 

package/react/useSub.js

@@ -158,6 +158,7 @@ function maybeThrottle (promise) {
 function registerCompatAttemptCleanup (signal, params) {
   // Compat hooks don't build per-hook init objects like Racer.
   // We still need a marker so trapRender can defer observer-shell cleanup
-  // to Suspense resolution instead of tearing the whole shell down immediately.
-  renderAttemptDestroyer.armCompat()
+  // only when a real attempt cleanup exists.
+  // This path must not arm suspense-gate keep-alive by itself.
+  renderAttemptDestroyer.armCompatAttemptCleanup()
 }

package/react/useSuspendMemo.js

@@ -28,7 +28,7 @@ export default function useSuspendMemo (factory, deps) {
   if (entry.status === 'done') return entry.value
   if (entry.status === 'pending') {
     markCompatComponent(componentId)
-    renderAttemptDestroyer.armCompat()
+    renderAttemptDestroyer.armSuspenseGate()
     throw entry.promise
   }
 
@@ -47,7 +47,7 @@ export default function useSuspendMemo (factory, deps) {
     entry.status = 'pending'
     entry.promise = promise
     markCompatComponent(componentId)
-    renderAttemptDestroyer.armCompat()
+    renderAttemptDestroyer.armSuspenseGate()
     throw promise
   }
 }