teamplay 0.5.0-alpha.31 → 0.5.0-alpha.33

package/dist/index.d.ts

@@ -58,7 +58,9 @@ export type { SubMode, SubOptions } from './orm/sub.js';
 export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
 export { default as useSuspendMemo, useSuspendMemoByKey } from './react/useSuspendMemo.js';
 export declare const observer: ObserverFunction;
-export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { emit, useOn, useEmit } from './orm/events.js';
+export { default as reaction } from './orm/reaction.js';
+export type { ReactionHandle, ReactionOptions } from './orm/reaction.js';
 export { useDidUpdate, useOnce, useSyncEffect } from './react/helpers.js';
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js';
 export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.js';

package/dist/index.js

@@ -18,7 +18,8 @@ export { default as sub, unsub } from "./orm/sub.js";
 export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";
 export { default as useSuspendMemo, useSuspendMemoByKey } from "./react/useSuspendMemo.js";
 export const observer = runtimeObserver;
-export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { emit, useOn, useEmit } from './orm/events.js';
+export { default as reaction } from "./orm/reaction.js";
 export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";
 export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./config.js";

package/dist/orm/Compat/SignalCompat.js

@@ -7,13 +7,13 @@ import { IS_QUERY, querySubscriptions } from '../Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
 import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from "../idFields.js";
 import { incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, setPublicDocReplace as _setPublicDocReplace, 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 { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js';
+import { on as onCustomEvent, removeListener as removeCustomEventListener } from '../events.js';
+import { waitForImperativeQueryReady } from '../queryReadiness.js';
+import { isModelEventsEnabled } 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, isSilentContextActive } from './silentContext.js';
+import { runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js';
 import universal$ from "../../react/universal$.js";
 import { getRootContext } from "../rootContext.js";
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
@@ -67,12 +67,6 @@ class SignalCompat extends Signal {
             return this.extra.get();
         return undefined;
     }
-    silent(value) {
-        if (arguments.length > 1)
-            throw Error('Signal.silent() expects zero or one argument');
-        const enabled = value == null ? true : !!value;
-        return createSilentSignalWrapper(this, enabled);
-    }
     get() {
         if (arguments.length > 0)
             throw Error('Signal.get() does not accept any arguments');
@@ -298,15 +292,8 @@ class SignalCompat extends Signal {
     on(eventName, pattern, handler) {
         if (arguments.length < 2)
             throw Error('Signal.on() expects at least two arguments');
-        if (eventName === 'change' || eventName === 'all') {
-            if (typeof pattern === 'function') {
-                return onCustomEvent(eventName, pattern);
-            }
-            if (typeof handler !== 'function')
-                throw Error('Signal.on() expects a handler function');
-            const normalized = normalizePattern(pattern, 'Signal.on()');
-            const rootId = (getRoot(this) || this)?.[ROOT_ID];
-            return onModelEvent(rootId, eventName, normalized, handler);
+        if ((eventName === 'change' || eventName === 'all') && typeof pattern !== 'function') {
+            throw Error('Signal model events are not supported. Use reaction() for signal changes.');
         }
         if (typeof pattern !== 'function')
             throw Error('Signal.on() expects a handler function');
@@ -315,16 +302,8 @@ class SignalCompat extends Signal {
     once(eventName, pattern, handler) {
         if (arguments.length < 2)
             throw Error('Signal.once() expects at least two arguments');
-        const isModelEvent = eventName === 'change' || eventName === 'all';
-        if (isModelEvent && typeof pattern !== 'function') {
-            if (typeof handler !== 'function')
-                throw Error('Signal.once() expects a handler function');
-            const onceHandler = (...args) => {
-                this.removeListener(eventName, onceHandler);
-                handler(...args);
-            };
-            this.on(eventName, pattern, onceHandler);
-            return onceHandler;
+        if ((eventName === 'change' || eventName === 'all') && typeof pattern !== 'function') {
+            throw Error('Signal model events are not supported. Use reaction() for signal changes.');
         }
         if (typeof pattern !== 'function')
             throw Error('Signal.once() expects a handler function');
@@ -338,10 +317,6 @@ class SignalCompat extends Signal {
     removeListener(eventName, handler) {
         if (arguments.length !== 2)
             throw Error('Signal.removeListener() expects two arguments');
-        if (eventName === 'change' || eventName === 'all') {
-            const rootId = (getRoot(this) || this)?.[ROOT_ID];
-            return removeModelListener(rootId, eventName, handler);
-        }
         return removeCustomEventListener(eventName, handler);
     }
     ref(path, target, options) {
@@ -433,53 +408,6 @@ class SignalCompat extends Signal {
             delete this[REF_TARGET];
     }
 }
-const SILENT_WRAPPER = Symbol('compat silent wrapper');
-const SILENT_WRAPPER_TARGET = Symbol('compat silent wrapper target');
-const SILENT_WRAPPER_ENABLED = Symbol('compat silent wrapper enabled');
-function createSilentSignalWrapper($signal, enabled = true) {
-    if (!$signal || typeof $signal !== 'function')
-        return $signal;
-    if ($signal[SILENT_WRAPPER]) {
-        const target = $signal[SILENT_WRAPPER_TARGET] || $signal;
-        return createSilentSignalWrapper(target, enabled);
-    }
-    const handler = {
-        get(target, key, receiver) {
-            if (key === SILENT_WRAPPER)
-                return true;
-            if (key === SILENT_WRAPPER_TARGET)
-                return target;
-            if (key === SILENT_WRAPPER_ENABLED)
-                return enabled;
-            if (key === 'silent') {
-                return function silentWrapper(value) {
-                    if (arguments.length > 1)
-                        throw Error('Signal.silent() expects zero or one argument');
-                    const nextEnabled = value == null ? true : !!value;
-                    return createSilentSignalWrapper(target, nextEnabled);
-                };
-            }
-            const value = Reflect.get(target, key, receiver);
-            if (isSignalLike(value)) {
-                return createSilentSignalWrapper(value, enabled);
-            }
-            if (typeof value === 'function') {
-                return function wrappedMethod(...args) {
-                    if (!enabled)
-                        return Reflect.apply(value, target, args);
-                    return runInSilentContext(() => Reflect.apply(value, target, args));
-                };
-            }
-            return value;
-        },
-        apply(target, thisArg, args) {
-            if (!enabled)
-                return Reflect.apply(target, thisArg, args);
-            return runInSilentContext(() => Reflect.apply(target, thisArg, args));
-        }
-    };
-    return new Proxy($signal, handler);
-}
 function getRefStore($signal) {
     const $root = getRoot($signal) || $signal;
     const rootId = $root?.[ROOT_ID];

package/dist/orm/Compat/silentContext.d.ts

@@ -1,5 +1,4 @@
 export function isSilentContextActive(): boolean;
 export function isModelEventsSilentContextActive(): boolean;
-export function runInSilentContext(fn: any): any;
 export function runInModelEventsSilentContext(fn: any): any;
 export function __resetSilentContextForTests(): void;

package/dist/orm/Compat/silentContext.js

@@ -1,20 +1,10 @@
-let silentDepth = 0;
 let modelEventsSilentDepth = 0;
 export function isSilentContextActive() {
-    return silentDepth > 0;
+    return false;
 }
 export function isModelEventsSilentContextActive() {
     return modelEventsSilentDepth > 0;
 }
-export function runInSilentContext(fn) {
-    silentDepth += 1;
-    try {
-        return fn();
-    }
-    finally {
-        silentDepth -= 1;
-    }
-}
 export function runInModelEventsSilentContext(fn) {
     modelEventsSilentDepth += 1;
     try {
@@ -25,6 +15,5 @@ export function runInModelEventsSilentContext(fn) {
     }
 }
 export function __resetSilentContextForTests() {
-    silentDepth = 0;
     modelEventsSilentDepth = 0;
 }

package/dist/orm/SignalBase.js

@@ -24,7 +24,6 @@ import { ROOT_FUNCTION, ROOT_ID, closeRootSignal, getRoot } from "./Root.js";
 import { getDefaultIdFields, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
 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';
 import { isPublicCollection } from "./signalPathKind.js";
 import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from "./signalSymbols.js";
@@ -853,23 +852,6 @@ export const extremelyLateBindings = {
                     }
                 }
             }
-            if (key === 'start') {
-                const [relativePath, ...depsAndGetter] = argumentsList;
-                if (typeof relativePath !== 'string')
-                    throw Error('Signal.start() expects targetPath to be a string');
-                const absolutePath = joinScopePath($parent.path(), relativePath);
-                return compatStartOnRoot(getRoot($parent) || $parent, absolutePath, ...depsAndGetter);
-            }
-            if (key === 'stop') {
-                if (argumentsList.length > 1)
-                    throw Error('Signal.stop() expects zero or one argument');
-                const relativePath = argumentsList.length === 0 ? '' : argumentsList[0];
-                if (relativePath != null && typeof relativePath !== 'string') {
-                    throw Error('Signal.stop() expects targetPath to be a string');
-                }
-                const absolutePath = joinScopePath($parent.path(), relativePath || '');
-                return compatStopOnRoot(getRoot($parent) || $parent, absolutePath);
-            }
         }
         throw Error(ERRORS.noSignalKey($parent, key));
     },

package/dist/orm/batchScheduler.d.ts

@@ -1,7 +1,7 @@
-export function beginBatch(): void;
-export function endBatch(): void;
-export function inBatch(): boolean;
-export function runInBatch(fn: any): any;
-export function scheduleReaction(reactionFn: any): void;
-export function flushReactions(): void;
-export function __resetBatchSchedulerForTests(): void;
+export function beginBatch (): void
+export function endBatch (): void
+export function inBatch (): boolean
+export function runInBatch<TResult> (fn: () => TResult): TResult
+export function scheduleReaction (reactionFn: () => unknown): void
+export function flushReactions (): void
+export function __resetBatchSchedulerForTests (): void

package/dist/orm/events.d.ts

@@ -0,0 +1,6 @@
+export const emit: any
+export const on: any
+export const removeListener: any
+export const useOn: any
+export const useEmit: any
+export const __resetEventsForTests: any

package/dist/orm/events.js

@@ -0,0 +1,48 @@
+import { useLayoutEffect } from 'react';
+const listeners = new Map();
+export function emit(eventName, ...args) {
+    const subs = listeners.get(eventName);
+    if (!subs)
+        return;
+    const snapshot = Array.from(subs);
+    for (const handler of snapshot) {
+        handler(...args);
+    }
+}
+export function on(eventName, handler) {
+    if (!listeners.has(eventName))
+        listeners.set(eventName, new Set());
+    const subs = listeners.get(eventName);
+    subs.add(handler);
+    return handler;
+}
+export function removeListener(eventName, handler) {
+    const subs = listeners.get(eventName);
+    if (!subs)
+        return;
+    subs.delete(handler);
+    if (!subs.size)
+        listeners.delete(eventName);
+}
+export function useOn(eventName, patternOrHandler, handler, deps) {
+    const isModelEvent = eventName === 'change' || eventName === 'all';
+    if (!isModelEvent || typeof patternOrHandler === 'function') {
+        if (typeof patternOrHandler !== 'function')
+            throw Error('useOn() expects a handler function');
+    }
+    else {
+        throw Error('Signal model events are not supported. Use reaction() for signal changes.');
+    }
+    useLayoutEffect(() => {
+        const listener = on(eventName, patternOrHandler);
+        return () => {
+            removeListener(eventName, listener);
+        };
+    }, [eventName, patternOrHandler, deps]);
+}
+export function useEmit() {
+    return emit;
+}
+export function __resetEventsForTests() {
+    listeners.clear();
+}

package/dist/orm/index.d.ts

@@ -4,4 +4,6 @@ export type { RootSignal, TeamplayCollections, TeamplayFeature, TeamplayFeatures
 export declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from './initModels.js';
+export { default as reaction } from './reaction.js';
+export type { ReactionHandle, ReactionOptions } from './reaction.js';
 export { defineSchema } from '@teamplay/schema';

package/dist/orm/index.js

@@ -3,4 +3,5 @@ export { belongsTo, hasMany, hasOne } from "./associations.js";
 export const BaseModel = Signal;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from "./initModels.js";
+export { default as reaction } from "./reaction.js";
 export { defineSchema } from '@teamplay/schema';

package/dist/orm/{Compat/queryReadiness.d.ts → queryReadiness.d.ts}

@@ -1,4 +1,4 @@
-import type { PathSegment } from '../types/path.js'
+import type { PathSegment } from './types/path.js'
 
 export function isDocReady (segments: readonly PathSegment[]): boolean
 

package/dist/orm/{Compat/queryReadiness.js → queryReadiness.js}

@@ -1,12 +1,12 @@
-import { getRaw } from '../dataTree.js';
-import { getConnection } from "../connection.js";
-import { isMissingShareDoc } from '../missingDoc.js';
-import { QUERIES, HASH, PARAMS, COLLECTION_NAME, querySubscriptions } from '../Query.js';
-import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
-import { getPrivateData, setPrivateData } from '../privateData.js';
-import { getRoot, ROOT_ID } from "../Root.js";
-import { isRootContextClosed } from "../rootContext.js";
-import { getScopedSignalHash, normalizeRootId } from "../rootScope.js";
+import { getRaw } from './dataTree.js';
+import { getConnection } from "./connection.js";
+import { isMissingShareDoc } from './missingDoc.js';
+import { QUERIES, HASH, PARAMS, COLLECTION_NAME, querySubscriptions } from './Query.js';
+import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from './Aggregation.js';
+import { getPrivateData, setPrivateData } from './privateData.js';
+import { getRoot, ROOT_ID } from "./Root.js";
+import { isRootContextClosed } from "./rootContext.js";
+import { getScopedSignalHash, normalizeRootId } from "./rootScope.js";
 let imperativeQueryReadyTimeoutMs = 1000;
 export function isQueryReady(collection, idsSegments, docsSegments, extraSegments, aggregationSegments, isAggregate, hasExtraResult) {
     if (hasExtraResult) {

package/dist/orm/reaction.d.ts

@@ -0,0 +1,11 @@
+export interface ReactionOptions {
+    lazy?: boolean;
+    debugger?: Function;
+    scheduler?: (run: () => unknown) => unknown;
+    onError?: (error: unknown) => unknown;
+}
+export interface ReactionHandle {
+    dispose: () => void;
+}
+export declare function reaction(fn: () => unknown, options?: ReactionOptions): ReactionHandle;
+export default reaction;

package/dist/orm/reaction.js

@@ -0,0 +1,47 @@
+import { observe, unobserve } from '@nx-js/observer-util';
+import { scheduleReaction } from './batchScheduler.js';
+export function reaction(fn, options = {}) {
+    if (typeof fn !== 'function')
+        throw Error('reaction() expects a function');
+    let disposed = false;
+    let pendingReactionFn;
+    function runReaction(runner) {
+        if (disposed)
+            return;
+        try {
+            return runner();
+        }
+        catch (error) {
+            if (typeof options.onError === 'function')
+                return options.onError(error);
+            throw error;
+        }
+    }
+    const scheduledRun = () => {
+        if (!pendingReactionFn)
+            return;
+        return runReaction(pendingReactionFn);
+    };
+    const runner = observe(fn, {
+        lazy: true,
+        debugger: options.debugger,
+        scheduler: (reactionFn) => {
+            pendingReactionFn = reactionFn;
+            if (typeof options.scheduler === 'function')
+                return options.scheduler(scheduledRun);
+            scheduleReaction(scheduledRun);
+        }
+    });
+    if (!options.lazy)
+        runReaction(runner);
+    return {
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            pendingReactionFn = undefined;
+            unobserve(runner);
+        }
+    };
+}
+export default reaction;

package/dist/react/useSub.js

@@ -4,7 +4,7 @@ import { useScheduleUpdate, useCache, useDefer } from "./helpers.js";
 import executionContextTracker from "./executionContextTracker.js";
 import * as promiseBatcher from "./promiseBatcher.js";
 import { getPrivateData } from '../orm/privateData.js';
-import { isDocReady } from '../orm/Compat/queryReadiness.js';
+import { isDocReady } from '../orm/queryReadiness.js';
 import { getRoot, ROOT_ID } from "../orm/Root.js";
 import { COLLECTION_NAME, HASH, IS_QUERY, PARAMS, QUERIES, querySubscriptions, materializeQueryDataDocsToCollection } from '../orm/Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../orm/Aggregation.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.31",
+  "version": "0.5.0-alpha.33",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -139,5 +139,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "efb7d7215b571620de2f7348ba1cd80e0cff7024"
+  "gitHead": "5355598efe68ec4d94d0a08b0450a1bd35358caa"
 }

package/dist/orm/Compat/eventsCompat.d.ts

@@ -1,3 +0,0 @@
-export const emit: any
-export const useOn: any
-export const useEmit: any

package/dist/orm/Compat/eventsCompat.js

@@ -1,73 +0,0 @@
-import { useLayoutEffect } from 'react';
-import { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener, __resetModelEventsForTests } from './modelEvents.js';
-const listeners = new Map();
-export function emit(eventName, ...args) {
-    const subs = listeners.get(eventName);
-    if (!subs)
-        return;
-    const snapshot = Array.from(subs);
-    for (const handler of snapshot) {
-        handler(...args);
-    }
-}
-export function on(eventName, handler) {
-    if (!listeners.has(eventName))
-        listeners.set(eventName, new Set());
-    const subs = listeners.get(eventName);
-    subs.add(handler);
-    return handler;
-}
-export function removeListener(eventName, handler) {
-    const subs = listeners.get(eventName);
-    if (!subs)
-        return;
-    subs.delete(handler);
-    if (!subs.size)
-        listeners.delete(eventName);
-}
-export function useOn(eventName, patternOrHandler, handler, deps) {
-    const isModelEvent = eventName === 'change' || eventName === 'all';
-    const isCustom = !isModelEvent || typeof patternOrHandler === 'function';
-    if (isCustom) {
-        if (typeof patternOrHandler !== 'function')
-            throw Error('useOn() expects a handler function');
-    }
-    else {
-        if (typeof handler !== 'function')
-            throw Error('useOn() expects a handler function');
-    }
-    const normalizedPattern = isCustom ? null : normalizePatternMaybe(patternOrHandler);
-    useLayoutEffect(() => {
-        if (isCustom) {
-            const listener = on(eventName, patternOrHandler);
-            return () => {
-                removeListener(eventName, listener);
-            };
-        }
-        if (normalizedPattern == null) {
-            handler(patternOrHandler);
-            return;
-        }
-        if (!isModelEventsEnabled())
-            return;
-        const listener = onModelEvent(undefined, eventName, normalizedPattern, handler);
-        return () => {
-            removeModelListener(undefined, eventName, listener);
-        };
-    }, [eventName, patternOrHandler, handler, deps, normalizedPattern, isCustom]);
-}
-export function useEmit() {
-    return emit;
-}
-export function __resetEventsForTests() {
-    listeners.clear();
-    __resetModelEventsForTests();
-}
-function normalizePatternMaybe(pattern) {
-    try {
-        return normalizePattern(pattern);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/orm/Compat/startStopCompat.d.ts

@@ -1,3 +0,0 @@
-export function compatStartOnRoot($root: any, targetPath: any, ...depsAndGetter: any[]): any;
-export function compatStopOnRoot($root: any, targetPath: any): void;
-export function joinScopePath(scopePath: any, relativePath: any): string;

package/dist/orm/Compat/startStopCompat.js

@@ -1,250 +0,0 @@
-import { observe, raw, unobserve } from '@nx-js/observer-util';
-import { getActiveDocOpContext } from '../Doc.js';
-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');
-export function compatStartOnRoot($root, targetPath, ...depsAndGetter) {
-    if (!isRootSignal($root))
-        throw Error('Signal.start() is only available on root signal');
-    if (typeof targetPath !== 'string')
-        throw Error('Signal.start() expects targetPath to be a string');
-    if (depsAndGetter.length < 1) {
-        throw Error('Signal.start() expects targetPath, dependencies, and a getter function');
-    }
-    const getter = depsAndGetter[depsAndGetter.length - 1];
-    if (typeof getter !== 'function') {
-        throw Error('Signal.start() expects the last argument to be a getter function');
-    }
-    const deps = depsAndGetter.slice(0, -1);
-    const targetSegments = parsePathSegments(targetPath);
-    const $target = resolveSignal($root, targetSegments);
-    const targetKey = $target.path();
-    const depPaths = deps
-        .map(dep => getStartDepPath(dep, $root))
-        .filter(Boolean);
-    const store = getStartStore($root);
-    const existing = store.get(targetKey);
-    if (existing)
-        existing.stop();
-    let lastSourceSnapshot = UNSET;
-    let lastTargetSnapshot = UNSET;
-    const reaction = observe(() => {
-        const resolvedDeps = [];
-        for (const dep of deps) {
-            const resolved = resolveStartDep(dep, $root);
-            if (resolved === SKIP_TICK)
-                return;
-            resolvedDeps.push(resolved);
-        }
-        let nextValue;
-        try {
-            nextValue = getter(...resolvedDeps);
-        }
-        catch (err) {
-            if (isThenable(err))
-                return;
-            throw err;
-        }
-        const sourceSnapshot = detachStartValue(nextValue);
-        if (lastSourceSnapshot !== UNSET && deepEqualStartValue(lastSourceSnapshot, sourceSnapshot)) {
-            return;
-        }
-        const currentTargetSnapshot = lastTargetSnapshot === UNSET
-            ? UNSET
-            : detachStartValue($target.peek());
-        if (currentTargetSnapshot !== UNSET && deepEqualStartValue(currentTargetSnapshot, sourceSnapshot)) {
-            lastSourceSnapshot = sourceSnapshot;
-            lastTargetSnapshot = sourceSnapshot;
-            return;
-        }
-        if (currentTargetSnapshot !== UNSET &&
-            !deepEqualStartValue(lastTargetSnapshot, currentTargetSnapshot) &&
-            isActiveLocalDocOpForDeps(depPaths)) {
-            lastSourceSnapshot = sourceSnapshot;
-            return;
-        }
-        lastSourceSnapshot = sourceSnapshot;
-        const detachedValue = detachStartValue(sourceSnapshot);
-        lastTargetSnapshot = detachStartValue(detachedValue);
-        // Keep the detached snapshot to avoid aliasing source and target.
-        // Old racer start() writes through diffDeep by default. In compat mode we must preserve
-        // that behavior, but also avoid reading the target reactively inside start(), otherwise
-        // start() subscribes to its own output and local child edits get immediately overwritten.
-        const maybePromise = $target.setDiffDeep(detachedValue);
-        if (maybePromise?.then) {
-            maybePromise
-                .then(() => { })
-                .catch(ignorePromiseRejection);
-        }
-    }, { scheduler: scheduleReaction });
-    store.set(targetKey, { stop: () => unobserve(reaction) });
-    return $target;
-}
-export function compatStopOnRoot($root, targetPath) {
-    if (!isRootSignal($root))
-        throw Error('Signal.stop() is only available on root signal');
-    if (typeof targetPath !== 'string')
-        throw Error('Signal.stop() expects targetPath to be a string');
-    const targetSegments = parsePathSegments(targetPath);
-    const $target = resolveSignal($root, targetSegments);
-    const targetKey = $target.path();
-    const store = getStartStore($root);
-    const existing = store.get(targetKey);
-    if (!existing)
-        return;
-    existing.stop();
-    store.delete(targetKey);
-}
-export function joinScopePath(scopePath, relativePath) {
-    if (typeof scopePath !== 'string')
-        scopePath = '';
-    const segments = [];
-    if (scopePath)
-        segments.push(...parsePathSegments(scopePath));
-    if (relativePath)
-        segments.push(...parsePathSegments(relativePath));
-    return segments.join('.');
-}
-function getStartStore($root) {
-    $root[START_REACTIONS] ??= new Map();
-    return $root[START_REACTIONS];
-}
-function resolveStartDep(dep, $root) {
-    try {
-        if (isSignalLike(dep))
-            return getStartDepValue(dep);
-        if (typeof dep === 'string')
-            return getStartDepValue(resolveSignal($root, parsePathSegments(dep)));
-        return dep;
-    }
-    catch (err) {
-        if (isThenable(err))
-            return SKIP_TICK;
-        throw err;
-    }
-}
-function getStartDepPath(dep, $root) {
-    if (isSignalLike(dep))
-        return dep.path();
-    if (typeof dep === 'string')
-        return resolveSignal($root, parsePathSegments(dep)).path();
-}
-function getStartDepValue($signal) {
-    return readReactiveSnapshot($signal.get());
-}
-function isActiveLocalDocOpForDeps(depPaths) {
-    const context = getActiveDocOpContext();
-    if (!context?.source)
-        return false;
-    const docPath = `${context.collection}.${context.docId}`;
-    return depPaths.some(depPath => depPath === docPath || depPath.startsWith(docPath + '.'));
-}
-function readReactiveSnapshot(value) {
-    if (!value || typeof value !== 'object')
-        return value;
-    if (value instanceof Date)
-        return new Date(value);
-    if (Array.isArray(value)) {
-        const array = [];
-        for (let i = 0; i < value.length; i++) {
-            array[i] = readReactiveSnapshot(value[i]);
-        }
-        return array;
-    }
-    const object = new value.constructor();
-    for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            object[key] = readReactiveSnapshot(value[key]);
-        }
-    }
-    return object;
-}
-function isSignalLike(value) {
-    return value && typeof value.path === 'function' && typeof value.get === 'function';
-}
-function parsePathSegments(path) {
-    return path.split('.').filter(Boolean);
-}
-function resolveSignal($base, segments) {
-    let $cursor = $base;
-    for (const segment of segments)
-        $cursor = $cursor[segment];
-    return $cursor;
-}
-function isRootSignal($signal) {
-    return getRoot($signal) === $signal;
-}
-function ignorePromiseRejection() { }
-function isThenable(value) {
-    return !!value && typeof value.then === 'function';
-}
-const UNSET = Symbol('compat start unset');
-function detachStartValue(value) {
-    const rawValue = raw(value);
-    if (!rawValue || typeof rawValue !== 'object')
-        return rawValue;
-    if (typeof globalThis.structuredClone === 'function') {
-        try {
-            return globalThis.structuredClone(rawValue);
-        }
-        catch { }
-    }
-    return racerDeepCopy(rawValue);
-}
-function racerDeepCopy(value) {
-    if (value instanceof Date)
-        return new Date(value);
-    if (typeof value === 'object') {
-        if (value === null)
-            return null;
-        if (Array.isArray(value)) {
-            const array = [];
-            for (let i = value.length; i--;) {
-                array[i] = racerDeepCopy(value[i]);
-            }
-            return array;
-        }
-        const object = new value.constructor();
-        for (const key in value) {
-            if (Object.prototype.hasOwnProperty.call(value, key)) {
-                object[key] = racerDeepCopy(value[key]);
-            }
-        }
-        return object;
-    }
-    return value;
-}
-function deepEqualStartValue(left, right) {
-    if (left === right)
-        return true;
-    if (Number.isNaN(left) && Number.isNaN(right))
-        return true;
-    if (left instanceof Date || right instanceof Date) {
-        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
-    }
-    if (!left || !right || typeof left !== 'object' || typeof right !== 'object')
-        return false;
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!Array.isArray(left) || !Array.isArray(right))
-            return false;
-        if (left.length !== right.length)
-            return false;
-        for (let i = 0; i < left.length; i++) {
-            if (!deepEqualStartValue(left[i], right[i]))
-                return false;
-        }
-        return true;
-    }
-    const leftKeys = Object.keys(left);
-    const rightKeys = Object.keys(right);
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    for (const key of leftKeys) {
-        if (!Object.prototype.hasOwnProperty.call(right, key))
-            return false;
-        if (!deepEqualStartValue(left[key], right[key]))
-            return false;
-    }
-    return true;
-}