teamplay 0.5.0-alpha.34 → 0.5.0-alpha.36

package/dist/index.d.ts

@@ -62,7 +62,7 @@ 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 { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly } from './orm/connection.js';
 export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.js';
 export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './config.js';
 export type { IdField, IdFields, TeamplayRuntimeConfig } from './config.js';

package/dist/index.js

@@ -21,7 +21,7 @@ export const observer = runtimeObserver;
 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 { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly } from "./orm/connection.js";
 export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./config.js";
 export { getSubscriptionGcDelay, setSubscriptionGcDelay } from "./orm/subscriptionGcDelay.js";
 export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from "./react/helpers.js";

package/dist/orm/Compat/SignalCompat.js

@@ -1,21 +1,13 @@
-import { raw, observe, unobserve } from '@nx-js/observer-util';
+import { raw } from '@nx-js/observer-util';
 import arrayDiff from 'arraydiff';
-import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection, isPublicCollectionSignal, isPublicDocumentSignal } from "../SignalBase.js";
-import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID } from "../Root.js";
-import { docSubscriptions } from '../Doc.js';
-import { IS_QUERY, querySubscriptions } from '../Query.js';
-import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
+import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection } from "../SignalBase.js";
+import { getRoot, ROOT, ROOT_ID } from "../Root.js";
+import { IS_QUERY } from '../Query.js';
+import { AGGREGATIONS, IS_AGGREGATION } 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 '../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 { 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';
 class SignalCompat extends Signal {
     static [GETTERS] = DEFAULT_GETTERS;
@@ -27,15 +19,9 @@ class SignalCompat extends Signal {
     getId() {
         if (isAggregationValuePath(this[SEGMENTS]))
             return super.getId();
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return $target.getId();
         return super.getId();
     }
     getCollection() {
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return $target.getCollection();
         return super.getCollection();
     }
     getCopy() {
@@ -48,16 +34,6 @@ class SignalCompat extends Signal {
             throw Error('Signal.getDeepCopy() does not accept any arguments');
         return deepCopy(this.get());
     }
-    fetch(...items) {
-        if (items.length > 0)
-            return subscribeMany(items, 'subscribe', 'fetch', 'fetch');
-        return subscribeSelf(this, 'fetch', 'fetch');
-    }
-    unfetch(...items) {
-        if (items.length > 0)
-            return subscribeMany(items, 'unsubscribe', 'fetch', 'unfetch');
-        return unsubscribeSelf(this, 'fetch', 'unfetch');
-    }
     getExtra() {
         if (arguments.length > 0)
             throw Error('Signal.getExtra() does not accept any arguments');
@@ -75,25 +51,14 @@ class SignalCompat extends Signal {
     peek() {
         if (arguments.length > 0)
             throw Error('Signal.peek() does not accept any arguments');
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return Signal.prototype.peek.apply($target, arguments);
         return Signal.prototype.peek.apply(this, arguments);
     }
     async set(value) {
-        const forwarded = forwardRef(this, 'set', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.set() expects a single argument');
-        if (value === undefined)
-            return Signal.prototype.set.call(this, value);
-        return setReplaceOnSignal(this, value);
+        return Signal.prototype.set.call(this, value);
     }
     async setReplace(value) {
-        const forwarded = forwardRef(this, 'setReplace', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setReplace() expects a single argument');
         if (value === undefined)
@@ -101,9 +66,6 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setNull(value) {
-        const forwarded = forwardRef(this, 'setNull', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setNull() expects a single argument');
         if (this.get() != null)
@@ -111,17 +73,11 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setDiffDeep(value) {
-        const forwarded = forwardRef(this, 'setDiffDeep', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setDiffDeep() expects a single argument');
         return runInBatch(() => setDiffDeepOnSignal(this, value));
     }
     async setDiff(value) {
-        const forwarded = forwardRef(this, 'setDiff', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setDiff() expects a single argument');
         const before = this.peek();
@@ -130,9 +86,6 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setEach(object) {
-        const forwarded = forwardRef(this, 'setEach', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setEach() expects a single argument');
         if (!object)
@@ -149,9 +102,6 @@ class SignalCompat extends Signal {
         });
     }
     async del() {
-        const forwarded = forwardRef(this, 'del', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.del() does not accept any arguments');
         try {
@@ -164,9 +114,6 @@ class SignalCompat extends Signal {
         }
     }
     async increment(byNumber) {
-        const forwarded = forwardRef(this, 'increment', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.increment() expects zero or one argument');
         if (byNumber != null && (typeof byNumber !== 'number' || !Number.isFinite(byNumber))) {
@@ -175,25 +122,16 @@ class SignalCompat extends Signal {
         return incrementOnSignal(this, byNumber);
     }
     async push(value) {
-        const forwarded = forwardRef(this, 'push', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.push() expects a single argument');
         return arrayPushOnSignal(this, value);
     }
     async unshift(value) {
-        const forwarded = forwardRef(this, 'unshift', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.unshift() expects a single argument');
         return arrayUnshiftOnSignal(this, value);
     }
     async insert(index, values) {
-        const forwarded = forwardRef(this, 'insert', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for insert');
         if (arguments.length > 2)
@@ -204,25 +142,16 @@ class SignalCompat extends Signal {
         return arrayInsertOnSignal(this, index, values);
     }
     async pop() {
-        const forwarded = forwardRef(this, 'pop', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.pop() does not accept any arguments');
         return arrayPopOnSignal(this);
     }
     async shift() {
-        const forwarded = forwardRef(this, 'shift', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.shift() does not accept any arguments');
         return arrayShiftOnSignal(this);
     }
     async remove(index, howMany) {
-        const forwarded = forwardRef(this, 'remove', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length === 0) {
             const segments = this[SEGMENTS].slice();
             if (!segments.length || typeof segments[segments.length - 1] !== 'number') {
@@ -241,9 +170,6 @@ class SignalCompat extends Signal {
         return arrayRemoveOnSignal(this, index, howMany);
     }
     async move(from, to, howMany) {
-        const forwarded = forwardRef(this, 'move', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for move');
         if (arguments.length > 3)
@@ -254,9 +180,6 @@ class SignalCompat extends Signal {
         return arrayMoveOnSignal(this, from, to, howMany);
     }
     async stringInsert(index, text) {
-        const forwarded = forwardRef(this, 'stringInsert', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for stringInsert');
         if (arguments.length > 2)
@@ -267,9 +190,6 @@ class SignalCompat extends Signal {
         return stringInsertOnSignal(this, index, text);
     }
     async stringRemove(index, howMany) {
-        const forwarded = forwardRef(this, 'stringRemove', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for stringRemove');
         if (arguments.length > 2)
@@ -282,9 +202,6 @@ class SignalCompat extends Signal {
         return stringRemoveOnSignal(this, index, howMany);
     }
     async assign(value) {
-        const forwarded = forwardRef(this, 'assign', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.assign() expects a single argument');
         return Signal.prototype.assign.call(this, value);
@@ -319,245 +236,15 @@ class SignalCompat extends Signal {
             throw Error('Signal.removeListener() expects two arguments');
         return removeCustomEventListener(eventName, handler);
     }
-    ref(path, target, options) {
-        if (arguments.length < 1 || arguments.length > 2)
-            throw Error('Signal.ref() expects one or two arguments');
-        let $to;
-        if (arguments.length === 1) {
-            $to = resolveRefTarget(this, path, 'Signal.ref()');
-        }
-        else {
-            $to = resolveRefTarget(this, path, 'Signal.ref()');
-            options = target;
-        }
-        if (!$to)
-            throw Error('Signal.ref() expects a target path or signal');
-        if (this === $to)
-            return this;
-        ensurePrivateRefSource(this, 'Signal.ref()');
-        const store = getRefStore(this);
-        const fromPath = this.path();
-        const existing = store.get(fromPath);
-        if (existing)
-            existing.stop();
-        const mirrorOnly = !!($to?.[IS_QUERY] || $to?.[IS_AGGREGATION]);
-        const { stop, onChange } = createRefLink(this, $to, { mirrorOnly, options });
-        store.set(fromPath, { stop });
-        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
-        const toRootId = (getRoot($to) || $to)?.[ROOT_ID];
-        if (!mirrorOnly) {
-            this[REF_TARGET] = $to;
-            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
-                mirrorOnly: false,
-                fromRootId,
-                toRootId
-            });
-        }
-        else {
-            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
-                mirrorOnly: true,
-                onChange,
-                fromRootId,
-                toRootId
-            });
-            if (this[REF_TARGET])
-                delete this[REF_TARGET];
-        }
-        return this;
-    }
-    refExtra(path) {
-        if (arguments.length !== 1)
-            throw Error('Signal.refExtra() expects a single argument');
-        const segments = parseAtSubpath(path, 1, 'Signal.refExtra()');
-        const $root = getRoot(this) || this;
-        const $target = resolveSignal($root, segments);
-        let $source = this;
-        if (this[IS_QUERY]) {
-            $source = this.extra;
-        }
-        return SignalCompat.prototype.ref.call($target, $source);
-    }
-    refIds(path) {
-        if (arguments.length !== 1)
-            throw Error('Signal.refIds() expects a single argument');
-        if (!this[IS_QUERY]) {
-            throw Error('Signal.refIds() can only be used on query signals');
-        }
-        const segments = parseAtSubpath(path, 1, 'Signal.refIds()');
-        const $root = getRoot(this) || this;
-        const $target = resolveSignal($root, segments);
-        return SignalCompat.prototype.ref.call($target, this.ids);
-    }
-    removeRef() {
-        if (arguments.length > 0)
-            throw Error('Signal.removeRef() does not accept any arguments');
-        const store = getRefStore(this);
-        const fromPath = this.path();
-        const existing = store.get(fromPath);
-        if (existing) {
-            existing.stop();
-            store.delete(fromPath);
-        }
-        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
-        removeRefLink(fromRootId, fromPath);
-        const $target = resolveRefSignal(this);
-        if ($target !== this) {
-            setDiffDeepBypassRef(this, deepCopy($target.get()));
-        }
-        if (this[REF_TARGET])
-            delete this[REF_TARGET];
-    }
-}
-function getRefStore($signal) {
-    const $root = getRoot($signal) || $signal;
-    const rootId = $root?.[ROOT_ID];
-    return getRootContext(rootId, true).activeRefs;
-}
-function createRefLink($from, $to, { mirrorOnly = false } = {}) {
-    let disposed = false;
-    let pendingRead = null;
-    let mirrorObserver;
-    const syncFromTarget = () => {
-        const value = readRefValue($to);
-        if (isThenable(value)) {
-            pendingRead = value;
-            value.then(() => {
-                if (disposed || pendingRead !== value)
-                    return;
-                pendingRead = null;
-                syncFromTarget();
-            }, () => {
-                if (pendingRead === value)
-                    pendingRead = null;
-            });
-            return;
-        }
-        if (value === undefined)
-            return;
-        setDiffDeepBypassRef($from, deepCopy(value));
-    };
-    syncFromTarget();
-    if (mirrorOnly) {
-        mirrorObserver = observe(() => {
-            syncFromTarget();
-            return readRefValue($to);
-        }, {
-            scheduler: job => job()
-        });
-        // initialize dependency graph
-        mirrorObserver();
-    }
-    return {
-        onChange: syncFromTarget,
-        stop: () => {
-            disposed = true;
-            if (mirrorObserver)
-                unobserve(mirrorObserver);
-            // Subsequent sync happens directly at mutation time via mirrorRefMutationFromTarget().
-        }
-    };
-}
-function readRefValue($signal) {
-    try {
-        return $signal.get();
-    }
-    catch (err) {
-        if (isThenable(err))
-            return err;
-        throw err;
-    }
 }
 function isAggregationValuePath(segments) {
     return Array.isArray(segments) &&
         segments.length >= 3 &&
         segments[0] === AGGREGATIONS;
 }
-function resolveRefSignal($signal) {
-    const directTarget = resolveRefSignalSafe($signal);
-    if (directTarget && directTarget !== $signal)
-        return directTarget;
-    const resolvedSegments = resolveRefSegmentsSafe($signal[SEGMENTS], (getRoot($signal) || $signal)?.[ROOT_ID]);
-    if (!resolvedSegments)
-        return $signal;
-    const $root = getRoot($signal) || $signal;
-    return resolveSignal($root, resolvedSegments);
-}
-function forwardRef($signal, methodName, args) {
-    const $target = resolveRefSignal($signal);
-    if ($target === $signal)
-        return null;
-    return SignalCompat.prototype[methodName].apply($target, args);
-}
-function setDiffDeepBypassRef($signal, value) {
-    const segments = $signal[SEGMENTS];
-    if (isPublicCollection(segments[0]))
-        return Signal.prototype.set.call($signal, 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 getAllRefLinks()) {
-        if (!isPathPrefix(link.toSegments, targetSegments))
-            continue;
-        const suffix = targetSegments.slice(link.toSegments.length);
-        updates.push({
-            fromRootId: link.fromRootId,
-            segments: link.fromSegments.concat(suffix),
-            value: deepCopy(value)
-        });
-    }
-    if (!updates.length)
-        return;
-    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);
-        }
-    });
-}
-function isPathPrefix(prefixSegments, fullSegments) {
-    if (prefixSegments.length > fullSegments.length)
-        return false;
-    for (let i = 0; i < prefixSegments.length; i++) {
-        if (String(prefixSegments[i]) !== String(fullSegments[i]))
-            return false;
-    }
-    return true;
-}
-function isSignalLike(value) {
-    return value && typeof value.path === 'function' && typeof value.get === 'function';
-}
 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') {
-        const segments = parseAtSubpath(target, 1, methodName);
-        const $root = getRoot($signal) || $signal;
-        return resolveSignal($root, segments);
-    }
-    return undefined;
-}
-function parseAtSubpath(subpath, argsLength, methodName) {
-    if (argsLength === 0)
-        return [];
-    if (typeof subpath === 'string')
-        return subpath.split('.').filter(Boolean);
-    if (typeof subpath === 'number' && Number.isFinite(subpath) && Number.isInteger(subpath))
-        return [subpath];
-    throw Error(`${methodName} expects a string or integer argument`);
-}
 function resolveSignal($signal, segments) {
     let $cursor = $signal;
     for (const segment of segments) {
@@ -716,9 +403,6 @@ function setReplacePrivateCompatSync($signal, value) {
         value = normalizeIdFields(value, idFields, segments[1]);
     }
     setReplacePrivateData(getOwningRootId($signal), segments, value);
-    if (shouldMirrorPrivateRefMutationLocally()) {
-        mirrorRefMutationFromTarget(segments, value);
-    }
 }
 function delPrivateCompatSync($signal, options) {
     const segments = $signal[SEGMENTS];
@@ -775,17 +459,9 @@ async function setReplaceOnSignal($signal, value) {
         value = normalizeIdFields(value, idFields, segments[1]);
     }
     if (isPublicCollection(segments[0])) {
-        const result = await _setPublicDocReplace(segments, value);
-        if (shouldMirrorPublicRefMutationLocally(segments)) {
-            mirrorRefMutationFromTarget(segments, value);
-        }
-        return result;
-    }
-    const result = setReplacePrivateData(getOwningRootId($signal), segments, value);
-    if (shouldMirrorPrivateRefMutationLocally()) {
-        mirrorRefMutationFromTarget(segments, value);
+        return _setPublicDocReplace(segments, value);
     }
-    return result;
+    return setReplacePrivateData(getOwningRootId($signal), segments, value);
 }
 async function incrementOnSignal($signal, byNumber) {
     const segments = $signal[SEGMENTS];
@@ -911,28 +587,6 @@ function getOwningRootId($signal) {
     const $root = getRoot($signal) || $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))
@@ -953,75 +607,6 @@ function deepCopy(value) {
     }
     return racerDeepCopy(rawValue);
 }
-function subscribeMany(items, action, intent = 'subscribe', methodName = action) {
-    const targets = flattenItems(items);
-    const promises = [];
-    for (const target of targets) {
-        if (!target)
-            continue;
-        if (!(target instanceof Signal)) {
-            throw Error(`Signal.${methodName}() accepts only Signal instances. Got: ${target}`);
-        }
-        const result = action === 'subscribe'
-            ? subscribeSelf(target, intent, methodName)
-            : unsubscribeSelf(target, intent, methodName);
-        if (result?.then)
-            promises.push(result);
-    }
-    if (promises.length)
-        return Promise.all(promises);
-}
-function flattenItems(items, result = []) {
-    for (const item of items) {
-        if (!item)
-            continue;
-        if (Array.isArray(item)) {
-            flattenItems(item, result);
-        }
-        else {
-            result.push(item);
-        }
-    }
-    return result;
-}
-function subscribeSelf($signal, intent = 'subscribe', methodName = 'subscribe') {
-    if ($signal[IS_QUERY]) {
-        return (async () => {
-            await querySubscriptions.subscribe($signal, { intent });
-            await waitForImperativeQueryReady($signal);
-        })();
-    }
-    if ($signal[IS_AGGREGATION]) {
-        return (async () => {
-            await aggregationSubscriptions.subscribe($signal, { intent });
-            await waitForImperativeQueryReady($signal);
-        })();
-    }
-    if (isPublicDocumentSignal($signal))
-        return docSubscriptions.subscribe($signal, { intent });
-    if (isPublicCollectionSignal($signal)) {
-        throw Error(`Signal.${methodName}() expects a document or query signal. Use sub($collection, params, { mode: 'fetch' }) for collection fetches.`);
-    }
-    if ($signal[SEGMENTS].length === 0) {
-        throw Error(`Signal.${methodName}() cannot be called on the root signal`);
-    }
-    throw Error(`Signal.${methodName}() expects a document or query signal`);
-}
-function unsubscribeSelf($signal, intent = 'subscribe', methodName = 'unsubscribe') {
-    if ($signal[IS_QUERY])
-        return querySubscriptions.unsubscribe($signal, { intent });
-    if ($signal[IS_AGGREGATION])
-        return aggregationSubscriptions.unsubscribe($signal, { intent });
-    if (isPublicDocumentSignal($signal))
-        return docSubscriptions.unsubscribe($signal, { intent });
-    if (isPublicCollectionSignal($signal)) {
-        throw Error(`Signal.${methodName}() expects a document or query signal`);
-    }
-    if ($signal[SEGMENTS].length === 0) {
-        throw Error(`Signal.${methodName}() cannot be called on the root signal`);
-    }
-    throw Error(`Signal.${methodName}() expects a document or query signal`);
-}
 // Racer-style deep copy:
 // - Preserves prototypes by instantiating via `new value.constructor()`
 // - Copies own enumerable props recursively