teamplay 0.5.0-alpha.8 → 0.5.0

package/dist/orm/dataTree.js

@@ -4,9 +4,6 @@ import diffMatchPatch from 'diff-match-patch';
 import { getConnection } from "./connection.js";
 import setDiffDeep from '../utils/setDiffDeep.js';
 import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject, isIdFieldPath } from "./idFields.js";
-import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js';
-import { isSilentContextActive } from './Compat/silentContext.js';
-import { isCompatEnv } from './compatEnv.js';
 import { isMissingShareDoc } from './missingDoc.js';
 import { getLogicalRootSnapshot as getLogicalRootSnapshotFromTree } from "./rootScope.js";
 import { getRootContext } from "./rootContext.js";
@@ -15,8 +12,6 @@ const ALLOW_PARTIAL_DOC_CREATION = false;
 export const dataTreeRaw = {};
 const dataTree = observable(dataTreeRaw);
 function getWritableTree(tree) {
-    if (isSilentContextActive())
-        return getTreeRaw(tree);
     return tree;
 }
 function getTreeRaw(tree) {
@@ -24,22 +19,6 @@ function getTreeRaw(tree) {
         return dataTreeRaw;
     return raw(tree) || tree;
 }
-function shouldEmitModelEvents(tree, eventContext) {
-    return (tree === dataTree || eventContext?.rootId != null) &&
-        isModelEventsEnabled() &&
-        !isSilentContextActive();
-}
-function emitModelEvent(segments, prevValue, meta, tree = dataTree, eventContext) {
-    if (!shouldEmitModelEvents(tree, eventContext))
-        return;
-    const treeRaw = getTreeRaw(tree);
-    const value = get(segments, treeRaw);
-    const logicalSegments = eventContext?.logicalSegments || segments;
-    const modelEventMeta = eventContext?.rootId != null
-        ? { ...meta, rootId: eventContext.rootId }
-        : meta;
-    emitModelChange(logicalSegments, value, prevValue, modelEventMeta);
-}
 export function resolveStorageSegments(rootId, logicalSegments) {
     return logicalSegments;
 }
@@ -59,10 +38,8 @@ export function get(segments, tree = dataTree) {
 export function getRaw(segments) {
     return get(segments, dataTreeRaw);
 }
-export function set(segments, value, tree = dataTree, eventContext) {
+export function set(segments, value, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     let dataNodeRaw = getTreeRaw(writableTree);
     for (let i = 0; i < segments.length - 1; i++) {
@@ -87,7 +64,6 @@ export function set(segments, value, tree = dataTree, eventContext) {
         return;
     if (value == null || typeof value !== 'object') {
         dataNode[key] = value;
-        emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext);
         return;
     }
     // instead of just setting the new value `dataNode[key] = value` we want
@@ -97,7 +73,6 @@ export function set(segments, value, tree = dataTree, eventContext) {
     // (we just set it to this value)
     if (dataNode[key] !== newValue)
         dataNode[key] = newValue;
-    emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext);
 }
 function hasOwnDataKey(node, key) {
     if (node == null)
@@ -107,10 +82,8 @@ function hasOwnDataKey(node, key) {
     return Object.prototype.hasOwnProperty.call(node, key);
 }
 // Like set(), but always assigns the value without equality checks or delete-on-null behavior
-export function setReplace(segments, value, tree = dataTree, eventContext) {
+export function setReplace(segments, value, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -127,12 +100,9 @@ export function setReplace(segments, value, tree = dataTree, eventContext) {
     }
     const key = segments[segments.length - 1];
     dataNode[key] = value;
-    emitModelEvent(segments, prevValue, { op: 'setReplace' }, tree, eventContext);
 }
-export function del(segments, tree = dataTree, eventContext) {
+export function del(segments, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -154,7 +124,6 @@ export function del(segments, tree = dataTree, eventContext) {
             return;
         delete dataNode[key];
     }
-    emitModelEvent(segments, prevValue, { op: 'del' }, tree, eventContext);
 }
 export async function setPublicDoc(segments, value, deleteValue = false) {
     if (segments.length === 0)
@@ -178,18 +147,18 @@ export async function setPublicDoc(segments, value, deleteValue = false) {
     if (isIdFieldPath(segments, idFields))
         return;
     const doc = getConnection().get(collection, docId);
-    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData: true });
+    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateDocDataFromLocal: true });
     if (!docState.exists && segments.length > 2) {
-        docState = await resolvePublicDocStateWithCompatFetchFallback({
+        docState = await resolvePublicDocStateWithLocalRecovery({
             collection,
             docId,
             doc,
             idFields,
-            hydrateCompatDocData: true
+            hydrateDocDataFromLocal: true
         });
     }
     if (!docState.exists && deleteValue)
-        throw Error(ERRORS.deleteNonExistentDoc(segments));
+        return;
     // make sure that the value is not observable to not trigger extra reads. And clone it
     value = raw(value);
     if (value == null) {
@@ -286,14 +255,14 @@ export async function setPublicDocReplace(segments, value) {
     if (isIdFieldPath(segments, idFields))
         return;
     const doc = getConnection().get(collection, docId);
-    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData: true });
+    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateDocDataFromLocal: true });
     if (!docState.exists && segments.length > 2) {
-        docState = await resolvePublicDocStateWithCompatFetchFallback({
+        docState = await resolvePublicDocStateWithLocalRecovery({
             collection,
             docId,
             doc,
             idFields,
-            hydrateCompatDocData: true
+            hydrateDocDataFromLocal: true
         });
     }
     // make sure that the value is not observable to not trigger extra reads. And clone it
@@ -336,7 +305,7 @@ 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
+    // setPublicDoc() 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)) {
@@ -374,9 +343,10 @@ async function createPublicDocAndHydrateLocal({ doc, collection, docId, newDoc,
     await new Promise((resolve, reject) => {
         doc.create(newDoc, err => err ? reject(err) : resolve());
     });
-    // In compatibility mode we must allow immediate subpath writes after create()
-    // even when the ShareDB snapshot hasn't been loaded via subscribe/fetch yet.
-    if (isCompatEnv() && doc?.data == null) {
+    // Keep public creates immediately writable even when the ShareDB snapshot has
+    // not been loaded via subscribe/fetch yet. UI flows rely on optimistic add()
+    // followed by child writes without waiting for DB confirmation.
+    if (doc?.data == null) {
         const localDoc = JSON.parse(JSON.stringify(newDoc || {}));
         if (isPlainObject(localDoc))
             injectIdFields(localDoc, idFields, docId);
@@ -387,7 +357,7 @@ async function createPublicDocAndHydrateLocal({ doc, collection, docId, newDoc,
     }
     ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields });
 }
-function resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData = false }) {
+function resolvePublicDocState({ collection, docId, doc, idFields, hydrateDocDataFromLocal = false }) {
     ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields });
     if (isMissingShareDoc(doc)) {
         return { exists: false, snapshot: undefined, source: 'none' };
@@ -400,24 +370,29 @@ function resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompat
         };
     }
     const localSnapshot = getRaw([collection, docId]);
-    if (!(isCompatEnv() && localSnapshot != null)) {
+    if (localSnapshot == null) {
         return { exists: false, snapshot: undefined, source: 'none' };
     }
-    // In compat mode local raw data can be the source of truth between create/add
-    // and later subpath mutations even if ShareDB doc.data is currently empty.
-    if (hydrateCompatDocData) {
+    // Local raw data can be the source of truth between add() and later subpath
+    // mutations even if ShareDB doc.data is currently empty or was recreated.
+    if (hydrateDocDataFromLocal) {
         doc.data = localSnapshot;
     }
     return { exists: true, snapshot: localSnapshot, source: 'local' };
 }
-async function resolvePublicDocStateWithCompatFetchFallback({ collection, docId, doc, idFields, hydrateCompatDocData = false }) {
-    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData });
-    if (docState.exists || !isCompatEnv())
+async function resolvePublicDocStateWithLocalRecovery({ collection, docId, doc, idFields, hydrateDocDataFromLocal = false }) {
+    let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateDocDataFromLocal });
+    if (docState.exists)
+        return docState;
+    const shouldFetch = getRaw([collection, docId]) != null &&
+        isMissingShareDoc(doc) &&
+        doc.version == null;
+    if (!shouldFetch)
         return docState;
     await new Promise((resolve, reject) => {
         doc.fetch(err => err ? reject(err) : resolve());
     });
-    docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData });
+    docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateDocDataFromLocal });
     return docState;
 }
 function ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields }) {
@@ -500,56 +475,38 @@ function getArrayNode(segments, tree = dataTree, create = true) {
     }
     return dataNode;
 }
-export function arrayPush(segments, value, tree = dataTree, eventContext) {
+export function arrayPush(segments, value, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const index = arr.length;
-    const result = arr.push(value);
-    emitModelEvent(segments.concat(index), undefined, { op: 'arrayPush', index }, tree, eventContext);
-    return result;
+    return arr.push(value);
 }
-export function arrayUnshift(segments, value, tree = dataTree, eventContext) {
+export function arrayUnshift(segments, value, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const result = arr.unshift(value);
-    emitModelEvent(segments.concat(0), undefined, { op: 'arrayUnshift', index: 0 }, tree, eventContext);
-    return result;
+    return arr.unshift(value);
 }
-export function arrayInsert(segments, index, values, tree = dataTree, eventContext) {
+export function arrayInsert(segments, index, values, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     const inserted = Array.isArray(values) ? values : [values];
     arr.splice(index, 0, ...inserted);
-    for (let i = 0; i < inserted.length; i++) {
-        emitModelEvent(segments.concat(index + i), undefined, { op: 'arrayInsert', index: index + i }, tree, eventContext);
-    }
     return arr.length;
 }
-export function arrayPop(segments, tree = dataTree, eventContext) {
+export function arrayPop(segments, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     if (!arr.length)
         return;
-    const index = arr.length - 1;
-    const previous = arr.pop();
-    emitModelEvent(segments.concat(index), previous, { op: 'arrayPop', index }, tree, eventContext);
-    return previous;
+    return arr.pop();
 }
-export function arrayShift(segments, tree = dataTree, eventContext) {
+export function arrayShift(segments, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     if (!arr.length)
         return;
-    const previous = arr.shift();
-    emitModelEvent(segments.concat(0), previous, { op: 'arrayShift', index: 0 }, tree, eventContext);
-    return previous;
+    return arr.shift();
 }
-export function arrayRemove(segments, index, howMany = 1, tree = dataTree, eventContext) {
+export function arrayRemove(segments, index, howMany = 1, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const removed = arr.splice(index, howMany);
-    for (let i = 0; i < removed.length; i++) {
-        emitModelEvent(segments.concat(index + i), removed[i], { op: 'arrayRemove', index: index + i, howMany }, tree, eventContext);
-    }
-    return removed;
+    return arr.splice(index, howMany);
 }
-export function arrayMove(segments, from, to, howMany = 1, tree = dataTree, eventContext) {
+export function arrayMove(segments, from, to, howMany = 1, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const prevValue = shouldEmitModelEvents(tree, eventContext) ? arr.slice() : undefined;
     const len = arr.length;
     if (from < 0)
         from += len;
@@ -557,7 +514,6 @@ export function arrayMove(segments, from, to, howMany = 1, tree = dataTree, even
         to += len;
     const moved = arr.splice(from, howMany);
     arr.splice(to, 0, ...moved);
-    emitModelEvent(segments, prevValue, { op: 'arrayMove', from, to, howMany }, tree, eventContext);
     return moved;
 }
 export async function incrementPublic(segments, byNumber) {
@@ -572,12 +528,12 @@ export async function incrementPublic(segments, byNumber) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -615,12 +571,12 @@ export async function arrayInsertPublic(segments, index, values) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -674,12 +630,12 @@ export async function arrayRemovePublic(segments, index, howMany = 1) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -702,12 +658,12 @@ export async function arrayMovePublic(segments, from, to, howMany = 1) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -726,7 +682,7 @@ export async function arrayMovePublic(segments, from, to, howMany = 1) {
         doc.submitOp(op, err => err ? reject(err) : resolve(moved));
     });
 }
-export function stringInsertLocal(segments, index, text, tree = dataTree, eventContext) {
+export function stringInsertLocal(segments, index, text, tree = dataTree) {
     let dataNode = getWritableTree(tree);
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -739,17 +695,15 @@ export function stringInsertLocal(segments, index, text, tree = dataTree, eventC
     const previous = dataNode[key];
     if (previous == null) {
         dataNode[key] = text;
-        emitModelEvent(segments, previous, { op: 'stringInsert', index }, tree, eventContext);
         return previous;
     }
     if (typeof previous !== 'string') {
         throw Error(`Expected string at ${segments.join('.')}`);
     }
     dataNode[key] = previous.slice(0, index) + text + previous.slice(index);
-    emitModelEvent(segments, previous, { op: 'stringInsert', index }, tree, eventContext);
     return previous;
 }
-export function stringRemoveLocal(segments, index, howMany, tree = dataTree, eventContext) {
+export function stringRemoveLocal(segments, index, howMany, tree = dataTree) {
     let dataNode = getWritableTree(tree);
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -765,7 +719,6 @@ export function stringRemoveLocal(segments, index, howMany, tree = dataTree, eve
         throw Error(`Expected string at ${segments.join('.')}`);
     }
     dataNode[key] = previous.slice(0, index) + previous.slice(index + howMany);
-    emitModelEvent(segments, previous, { op: 'stringRemove', index, howMany }, tree, eventContext);
     return previous;
 }
 export async function stringInsertPublic(segments, index, text) {
@@ -780,12 +733,12 @@ export async function stringInsertPublic(segments, index, text) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -814,12 +767,12 @@ export async function stringRemovePublic(segments, index, howMany) {
         throw Error(ERRORS.publicDoc(segments));
     const doc = getConnection().get(collection, docId);
     const idFields = getIdFieldsForSegments([collection, docId]);
-    const docState = await resolvePublicDocStateWithCompatFetchFallback({
+    const docState = await resolvePublicDocStateWithLocalRecovery({
         collection,
         docId,
         doc,
         idFields,
-        hydrateCompatDocData: true
+        hydrateDocDataFromLocal: true
     });
     if (!docState.exists)
         throw Error(ERRORS.nonExistingDoc(segments));
@@ -853,11 +806,6 @@ const ERRORS = {
   `,
     publicDocIdNumber: segments => `
     Public doc id must be a string. Got a number: ${segments}
-  `,
-    deleteNonExistentDoc: segments => `
-    Trying to delete data from a non-existing doc ${segments}.
-    Make sure that the document exists and you are subscribed to it
-    before trying to delete anything from it or the doc itself.
   `,
     publicDocIdUndefined: segments => `
     Trying to modify a public document with the id 'undefined'.

package/dist/orm/disposeRootContext.js

@@ -27,9 +27,6 @@ async function runDispose(rootId) {
     const context = getRootContext(rootId, false);
     if (!context)
         return;
-    stopActiveRefs(context);
-    context.resetRefs();
-    context.resetModelListeners();
     for (const transportHash of Array.from(context.queryRuntimeHashes)) {
         await querySubscriptions.destroyByRuntimeHash(transportHash, { rootId, force: true });
     }
@@ -43,17 +40,6 @@ async function runDispose(rootId) {
     context.resetDirectDocSubscriptions();
     deleteRootContext(rootId);
 }
-function stopActiveRefs(context) {
-    for (const entry of context.activeRefs.values()) {
-        try {
-            entry?.stop?.();
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-    context.resetActiveRefs();
-}
 export function __resetPendingRootDisposesForTests() {
     PENDING_DISPOSES.clear();
 }

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/getSignal.d.ts

@@ -10,7 +10,7 @@ export interface GetSignalOptions {
 }
 declare const PROXIES_CACHE: Cache<RootSignalRuntime>;
 export default function getSignal($root?: RootSignalRuntime, segments?: PathSegment[], { useExtremelyLateBindings, rootId, signalHash, proxyHandlers }?: GetSignalOptions): RootSignalRuntime;
-export declare function getSignalClass(segments: PathSegment[], rootId?: string): SignalModelConstructor;
+export declare function getSignalClass(segments: PathSegment[], _rootId?: string): SignalModelConstructor;
 export declare function rawSignal(proxy: unknown): RootSignalRuntime | undefined;
 export { PROXIES_CACHE as __DEBUG_SIGNALS_CACHE__ };
 export declare function purgeSignalHashes(hashes: Iterable<string>): void;

package/dist/orm/getSignal.js

@@ -1,13 +1,10 @@
 import Cache from "./Cache.js";
-import Signal, { SEGMENTS, regularBindings, extremelyLateBindings, isPublicCollection, isPrivateCollection } from "./Signal.js";
+import Signal, { regularBindings, extremelyLateBindings, isPublicCollection, isPrivateCollection } from "./Signal.js";
 import { findModel } from "./addModel.js";
 import { LOCAL } from './$.js';
 import { ROOT, ROOT_ID, GLOBAL_ROOT_ID } from "./Root.js";
 import { QUERIES } from './Query.js';
 import { AGGREGATIONS } from './Aggregation.js';
-import { isCompatEnv } from './compatEnv.js';
-import { getConnection } from "./connection.js";
-import { resolveRefSegmentsSafe } from './Compat/refFallback.js';
 import { getSignalIdentityHash } from "./rootScope.js";
 import { isRootContextClosed, registerRootOwnedSignalHash } from "./rootContext.js";
 const PROXIES_CACHE = new Cache();
@@ -80,38 +77,12 @@ export default function getSignal($root, segments = [], { useExtremelyLateBindin
     return proxy;
 }
 function getDefaultProxyHandlers({ useExtremelyLateBindings } = {}) {
-    const baseHandlers = (useExtremelyLateBindings ? extremelyLateBindings : regularBindings);
-    if (!isCompatEnv() || baseHandlers !== extremelyLateBindings)
-        return baseHandlers;
-    return {
-        ...baseHandlers,
-        get(signal, key, receiver) {
-            if (key === 'connection' && signal[SEGMENTS].length === 0) {
-                try {
-                    return getConnection();
-                }
-                catch {
-                    return undefined;
-                }
-            }
-            return baseHandlers.get
-                ? baseHandlers.get(signal, key, receiver)
-                : Reflect.get(signal, key, receiver);
-        }
-    };
+    return (useExtremelyLateBindings ? extremelyLateBindings : regularBindings);
 }
-export function getSignalClass(segments, rootId = GLOBAL_ROOT_ID) {
-    let Model = findModel(segments);
+export function getSignalClass(segments, _rootId = GLOBAL_ROOT_ID) {
+    const Model = findModel(segments);
     if (Model)
         return Model;
-    if (!isCompatEnv())
-        return Signal;
-    const dereferencedSegments = resolveRefSegmentsSafe(segments, rootId);
-    if (dereferencedSegments) {
-        Model = findModel(dereferencedSegments);
-        if (Model)
-            return Model;
-    }
     return Signal;
 }
 export function rawSignal(proxy) {

package/dist/orm/idFields.d.ts

@@ -2,13 +2,22 @@ import type { PathSegment } from './types/path.js';
 export type IdField = string;
 export type IdFields = readonly IdField[];
 export type PlainObject = Record<string, unknown>;
+export interface TeamplayRuntimeConfig {
+    idFields?: IdFields | null;
+}
 export declare const DEFAULT_ID_FIELDS: readonly ["_id"];
+export declare const TEAMPLAY_RUNTIME_CONFIG_SYMBOL: unique symbol;
 export declare function getIdFieldsForSegments(segments: PathSegment[]): IdFields;
+export declare function configureTeamplay({ idFields }?: TeamplayRuntimeConfig): void;
+export declare function getTeamplayConfig(): Required<TeamplayRuntimeConfig>;
+export declare function getDefaultIdFields(): IdFields;
+export declare function setDefaultIdFields(idFields?: IdFields): void;
+export declare function __resetTeamplayConfigForTests(): void;
 export declare function isPlainObject(value: unknown): value is PlainObject;
 export declare function injectIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function normalizeIdFields<TValue>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function stripIdFields<TValue>(value: TValue, idFields: IdFields): TValue;
-export declare function resolveAddDocId(value: unknown, getDefaultId: () => string): PathSegment;
+export declare function resolveAddDocId(value: unknown, idFields: IdFields, getDefaultId: () => string): PathSegment;
 export declare function prepareAddPayload<TValue extends object>(value: TValue, idFields: IdFields, docId: PathSegment): TValue;
 export declare function isPublicDocPath(segments: unknown): segments is [string, PathSegment];
 export declare function isIdFieldPath(segments: unknown, idFields: IdFields): segments is [string, PathSegment, string];