teamplay 0.5.0-alpha.4 → 0.5.0-alpha.7

package/dist/index.d.ts

@@ -1,15 +1,31 @@
 import type * as React from 'react';
 import { SEGMENTS } from './orm/Signal.js';
 import useApi from './react/useApi.js';
-import type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, LocalSignalFactory, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalChild, SignalBaseInstance, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalClass, SignalCollectionMethods, SignalConstructor, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './orm/Signal.js';
+import type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest, PrivateSignalFromSpec, PublicSignal, LocalSignalFactory, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootPrivateCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalChild, SignalBaseInstance, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalClass, SignalCollectionMethods, SignalConstructor, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './orm/Signal.js';
 export interface TeamplayCollections {
 }
+export interface TeamplayPrivateCollections {
+}
 export interface TeamplayModels {
 }
 export interface TeamplaySignalFields {
 }
+export interface TeamplayPluginCollections {
+}
+export interface TeamplayPluginPrivateCollections {
+}
+export interface TeamplayPluginModels {
+}
+export interface TeamplayPluginSignalFields {
+}
+export interface TeamplayPluginOptions {
+}
+export interface TeamplayFeatures {
+}
+export type TeamplayPluginOption<TName extends string> = TName extends keyof TeamplayPluginOptions ? TeamplayPluginOptions[TName] : {};
+export type TeamplayFeature<TName extends string> = TName extends keyof TeamplayFeatures ? TeamplayFeatures[TName] : unknown;
 export type Signal<TValue = unknown> = PublicSignal<TValue>;
-export type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSpec, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, CollectionsFromManifest, LocalSignalFactory, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalCollectionMethods, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec };
+export type { AnySignal, ArraySignal, CollectionDocument, CollectionDocumentModel, CollectionSignal, CollectionSpec, CollectionSignalFromSpec, CollectionAggregationSignal, CollectionQuerySignal, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, ModelEntry, ModelManifest, CollectionsFromManifest, PrivateCollectionsFromManifest, LocalSignalFactory, PathModelsFromManifest, PrivateSignalFromSpec, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, RootCollections, RootSignal, WildcardPathSegment, WildcardSignalPath, AppendPath, ComputedQueryParamsInput, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, RootPrivateCollections, SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalCollectionMethods, SignalForKind, SignalKind, SignalMetadataMethods, SignalModelConstructor, SignalStringMutatorMethods, SignalValueMethods, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec };
 export interface ObserverOptions {
     forwardRef?: boolean;
     cache?: boolean;
@@ -36,8 +52,6 @@ export { defineModels, default as initModels, getModels, resetModelsForTests } f
 export { default as signal } from './orm/getSignal.js';
 export { GLOBAL_ROOT_ID } from './orm/Root.js';
 export declare const $: RootSignal;
-export declare const $root: RootSignal;
-export declare const model: RootSignal;
 export default $;
 export { default as sub } from './orm/sub.js';
 export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
@@ -54,7 +68,7 @@ export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, p
 export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation';
 export { accessControl } from '@teamplay/utils/accessControl';
 export type { AggregationCallback, AggregationContext, AggregationFunction, AggregationMeta, AggregationParams, AggregationQuery, ClientAggregationFunction, DefaultAggregationSession } from '@teamplay/utils/aggregation';
-export type { AccessControl, AccessControlRules, AccessCreateContext, AccessDecision, AccessDeleteContext, AccessOperation, AccessReadContext, AccessRule, AccessUpdateContext, AccessValidator, AccessValidatorObject, DefaultAccessSession } from '@teamplay/utils/accessControl';
+export type { AccessControl, AccessControlOptions, AccessControlRules, AccessCreateContext, AccessDecision, AccessDeleteContext, AccessOperation, AccessReadContext, AccessRule, AccessUpdateContext, AccessValidator, AccessValidatorObject, DefaultAccessSession } from '@teamplay/utils/accessControl';
 export declare function batch(): undefined;
 export declare function batch<TResult>(fn: () => TResult): TResult;
 export declare function batchModel(): undefined;
@@ -63,4 +77,5 @@ export declare function serverOnly<TValue>(value: TValue): TValue;
 export declare function clone<TValue>(value: TValue): TValue;
 export declare function initLocalCollection(name: string): any;
 export { useApi };
-export declare function getRootSignal<TCollections extends Record<string, any> = TeamplayCollections>(options?: Record<string, any>): RootSignal<TCollections>;
+export declare function getRootSignal(options?: Record<string, any>): RootSignal;
+export declare function getRootSignal<TCollections extends Record<string, any>>(options?: Record<string, any>): RootSignal<TCollections>;

package/dist/index.js

@@ -13,8 +13,6 @@ export { default as signal } from "./orm/getSignal.js";
 export { GLOBAL_ROOT_ID } from "./orm/Root.js";
 const getRuntimeRootSignal = _getRootSignal;
 export const $ = getRuntimeRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ });
-export const $root = $;
-export const model = $;
 export default $;
 export { default as sub } from "./orm/sub.js";
 export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";

package/dist/orm/Compat/SignalCompat.js

@@ -21,27 +21,14 @@ import disposeRootContext from "../disposeRootContext.js";
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
 class SignalCompat extends Signal {
     static ID_FIELDS = ['_id', 'id'];
-    static [GETTERS] = [...DEFAULT_GETTERS, 'at', 'scope', 'getCopy', 'getDeepCopy'];
+    static [GETTERS] = [...DEFAULT_GETTERS, 'getCopy', 'getDeepCopy'];
     get root() {
-        return this.scope();
+        return getRoot(this) || this;
     }
-    path(subpath) {
-        if (arguments.length > 1)
-            throw Error('Signal.path() expects a single argument');
-        if (arguments.length === 0)
-            return super.path();
-        const segments = parseAtSubpath(subpath, arguments.length, 'Signal.path()');
-        if (segments.length === 0)
-            return super.path();
-        return [...this[SEGMENTS], ...segments].join('.');
-    }
-    at(subpath) {
-        const segments = arguments.length > 1
-            ? parseAtSegments(arguments, 'Signal.at()')
-            : parseAtSubpath(subpath, arguments.length, 'Signal.at()');
-        if (segments.length === 0)
-            return this;
-        return resolveRelativePathTarget(this, segments);
+    path() {
+        if (arguments.length > 0)
+            throw Error('Signal.path() does not accept any arguments');
+        return super.path();
     }
     getId() {
         const $target = resolveRefSignal(this);
@@ -55,19 +42,15 @@ class SignalCompat extends Signal {
             return $target.getCollection();
         return super.getCollection();
     }
-    getCopy(subpath) {
-        if (arguments.length > 1)
-            throw Error('Signal.getCopy() expects a single argument');
-        const segments = parseAtSubpath(subpath, arguments.length, 'Signal.getCopy()');
-        const value = getSignalValueAt(this, segments);
-        return shallowCopy(value);
+    getCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getCopy() does not accept any arguments');
+        return shallowCopy(this.get());
     }
-    getDeepCopy(subpath) {
-        if (arguments.length > 1)
-            throw Error('Signal.getDeepCopy() expects a single argument');
-        const segments = parseAtSubpath(subpath, arguments.length, 'Signal.getDeepCopy()');
-        const value = getSignalValueAt(this, segments);
-        return deepCopy(value);
+    getDeepCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getDeepCopy() does not accept any arguments');
+        return deepCopy(this.get());
     }
     query(collection, params, options) {
         if (arguments.length < 1 || arguments.length > 3)
@@ -136,60 +119,37 @@ class SignalCompat extends Signal {
         return createSilentSignalWrapper(this, enabled);
     }
     get() {
-        if (arguments.length > 1) {
-            const segments = parseAtSegments(arguments, 'Signal.get()');
-            const $target = resolveRelativePathTarget(this, segments);
-            return Signal.prototype.get.call($target);
-        }
-        if (arguments.length === 1) {
-            if (arguments[0] == null) {
-                return Signal.prototype.get.apply(this, []);
-            }
-            const segments = parseAtSubpath(arguments[0], 1, 'Signal.get()');
-            const $target = resolveRelativePathTarget(this, segments);
-            return Signal.prototype.get.call($target);
-        }
+        if (arguments.length > 0)
+            throw Error('Signal.get() does not accept any arguments');
         return Signal.prototype.get.apply(this, arguments);
     }
     peek() {
-        if (arguments.length > 1) {
-            const segments = parseAtSegments(arguments, 'Signal.peek()');
-            const $target = resolveRelativePathTarget(this, segments);
-            return Signal.prototype.peek.call($target);
-        }
-        if (arguments.length === 1) {
-            if (arguments[0] == null) {
-                const $target = resolveRefSignal(this);
-                if ($target !== this)
-                    return Signal.prototype.peek.apply($target, []);
-                return Signal.prototype.peek.apply(this, []);
-            }
-            const segments = parseAtSubpath(arguments[0], 1, 'Signal.peek()');
-            const $target = resolveRelativePathTarget(this, segments);
-            return Signal.prototype.peek.call($target);
-        }
+        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(path, value) {
+    async set(value) {
         const forwarded = forwardRef(this, 'set', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.set() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.set()');
-        }
-        else if (arguments.length === 1) {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
+        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);
+    }
+    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)
-            return Signal.prototype.set.call($target, value);
-        return setReplaceOnSignal($target, value);
+            return Signal.prototype.set.call(this, value);
+        return setReplaceOnSignal(this, value);
     }
     async add(collectionOrValue, value) {
         const isRoot = this[SEGMENTS].length === 0;
@@ -207,102 +167,56 @@ class SignalCompat extends Signal {
             throw Error('Signal.add() expects a single argument');
         return Signal.prototype.add.call(this, collectionOrValue);
     }
-    async setNull(path, value) {
+    async setNull(value) {
         const forwarded = forwardRef(this, 'setNull', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.setNull() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.setNull()');
-        }
-        else if (arguments.length === 1) {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
-        if ($target.get() != null)
+        if (arguments.length > 1)
+            throw Error('Signal.setNull() expects a single argument');
+        if (this.get() != null)
             return;
-        return setReplaceOnSignal($target, value);
+        return setReplaceOnSignal(this, value);
     }
-    async create(path, value) {
+    async create(value) {
         const forwarded = forwardRef(this, 'create', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.create() expects zero to two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.create()');
-        }
-        else if (arguments.length === 1) {
-            if (typeof path === 'string' || typeof path === 'number') {
-                segments = parseAtSubpath(path, 1, 'Signal.create()');
-                value = {};
-            }
-            else {
-                value = path;
-            }
-        }
-        else {
+        if (arguments.length > 1)
+            throw Error('Signal.create() expects zero or one argument');
+        if (arguments.length === 0) {
             value = {};
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        ensureCreateTarget($target, 'Signal.create()');
-        if ($target.get() != null) {
-            throw Error(`Signal.create() may only be used on a non-existing document path. Path: ${$target.path()}`);
+        ensureCreateTarget(this, 'Signal.create()');
+        if (this.get() != null) {
+            throw Error(`Signal.create() may only be used on a non-existing document path. Path: ${this.path()}`);
         }
-        return setReplaceOnSignal($target, value);
+        return setReplaceOnSignal(this, value);
     }
-    async setDiffDeep(path, value) {
+    async setDiffDeep(value) {
         const forwarded = forwardRef(this, 'setDiffDeep', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.setDiffDeep() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.setDiffDeep()');
-        }
-        else if (arguments.length === 1) {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
-        return runInBatch(() => setDiffDeepOnSignal($target, value));
+        if (arguments.length > 1)
+            throw Error('Signal.setDiffDeep() expects a single argument');
+        return runInBatch(() => setDiffDeepOnSignal(this, value));
     }
-    async setDiff(path, value) {
+    async setDiff(value) {
         const forwarded = forwardRef(this, 'setDiff', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.setDiff() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.setDiff()');
-        }
-        else if (arguments.length === 1) {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
-        const before = $target.peek();
+        if (arguments.length > 1)
+            throw Error('Signal.setDiff() expects a single argument');
+        const before = this.peek();
         if (racerEqualCompat(before, value))
             return;
-        return setReplaceOnSignal($target, value);
+        return setReplaceOnSignal(this, value);
     }
-    async setEach(path, object) {
+    async setEach(object) {
         const forwarded = forwardRef(this, 'setEach', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.setEach() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.setEach()');
-        }
-        else if (arguments.length === 1) {
-            object = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
+        if (arguments.length > 1)
+            throw Error('Signal.setEach() expects a single argument');
         if (!object)
             return;
         if (typeof object !== 'object') {
@@ -311,126 +225,83 @@ class SignalCompat extends Signal {
         return runInBatch(async () => {
             const promises = [];
             for (const key of Object.keys(object)) {
-                promises.push(SignalCompat.prototype.set.call($target[key], object[key]));
+                promises.push(SignalCompat.prototype.set.call(this[key], object[key]));
             }
             await Promise.all(promises);
         });
     }
-    async del(path) {
+    async del() {
         const forwarded = forwardRef(this, 'del', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 1)
-            throw Error('Signal.del() expects a single argument');
-        const segments = parseAtSubpath(path, arguments.length, 'Signal.del()');
-        const $target = resolveRelativePathTarget(this, segments);
+        if (arguments.length > 0)
+            throw Error('Signal.del() does not accept any arguments');
         try {
-            return await Signal.prototype.del.call($target);
+            return await Signal.prototype.del.call(this);
         }
         catch (error) {
-            if (isMissingPublicDocDeleteError($target, error))
+            if (isMissingPublicDocDeleteError(this, error))
                 return;
             throw error;
         }
     }
-    async increment(path, byNumber) {
+    async increment(byNumber) {
         const forwarded = forwardRef(this, 'increment', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.increment() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.increment()');
-        }
-        else if (arguments.length === 1) {
-            if (typeof path === 'number') {
-                byNumber = path;
-            }
-            else {
-                segments = parseAtSubpath(path, 1, 'Signal.increment()');
-            }
+        if (arguments.length > 1)
+            throw Error('Signal.increment() expects zero or one argument');
+        if (byNumber != null && (typeof byNumber !== 'number' || !Number.isFinite(byNumber))) {
+            throw Error('Signal.increment() expects a numeric argument');
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        return incrementOnSignal($target, byNumber);
+        return incrementOnSignal(this, byNumber);
     }
-    async push(path, value) {
+    async push(value) {
         const forwarded = forwardRef(this, 'push', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.push() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.push()');
-        }
-        else {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayPushOnSignal($target, value);
+        if (arguments.length > 1)
+            throw Error('Signal.push() expects a single argument');
+        return arrayPushOnSignal(this, value);
     }
-    async unshift(path, value) {
+    async unshift(value) {
         const forwarded = forwardRef(this, 'unshift', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 2)
-            throw Error('Signal.unshift() expects one or two arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            segments = parseAtSubpath(path, 1, 'Signal.unshift()');
-        }
-        else {
-            value = path;
-        }
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayUnshiftOnSignal($target, value);
+        if (arguments.length > 1)
+            throw Error('Signal.unshift() expects a single argument');
+        return arrayUnshiftOnSignal(this, value);
     }
-    async insert(path, index, values) {
+    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 > 3)
-            throw Error('Signal.insert() expects two or three arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            index = arguments[0];
-            values = arguments[1];
-        }
-        else {
-            segments = parseAtSubpath(path, 1, 'Signal.insert()');
-            index = arguments[1];
-            values = arguments[2];
-        }
+        if (arguments.length > 2)
+            throw Error('Signal.insert() expects two arguments');
         if (typeof index !== 'number' || !Number.isFinite(index)) {
             throw Error('Signal.insert() expects a numeric index');
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayInsertOnSignal($target, index, values);
+        return arrayInsertOnSignal(this, index, values);
     }
-    async pop(path) {
+    async pop() {
         const forwarded = forwardRef(this, 'pop', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 1)
-            throw Error('Signal.pop() expects a single argument');
-        const segments = parseAtSubpath(path, arguments.length, 'Signal.pop()');
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayPopOnSignal($target);
+        if (arguments.length > 0)
+            throw Error('Signal.pop() does not accept any arguments');
+        return arrayPopOnSignal(this);
     }
-    async shift(path) {
+    async shift() {
         const forwarded = forwardRef(this, 'shift', arguments);
         if (forwarded)
             return forwarded;
-        if (arguments.length > 1)
-            throw Error('Signal.shift() expects a single argument');
-        const segments = parseAtSubpath(path, arguments.length, 'Signal.shift()');
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayShiftOnSignal($target);
+        if (arguments.length > 0)
+            throw Error('Signal.shift() does not accept any arguments');
+        return arrayShiftOnSignal(this);
     }
-    async remove(path, index, howMany) {
+    async remove(index, howMany) {
         const forwarded = forwardRef(this, 'remove', arguments);
         if (forwarded)
             return forwarded;
@@ -444,129 +315,53 @@ class SignalCompat extends Signal {
             const $target = resolveSignal($root, segments);
             return arrayRemoveOnSignal($target, +index, howMany);
         }
-        if (arguments.length < 1)
-            throw Error('Not enough arguments for remove');
-        if (arguments.length > 3)
-            throw Error('Signal.remove() expects one to three arguments');
-        let segments = [];
-        if (arguments.length === 1) {
-            if (typeof path === 'number') {
-                index = path;
-            }
-            else {
-                segments = parseAtSubpath(path, 1, 'Signal.remove()');
-            }
-        }
-        else if (arguments.length === 2) {
-            if (typeof path === 'number') {
-                index = path;
-                howMany = arguments[1];
-            }
-            else {
-                segments = parseAtSubpath(path, 1, 'Signal.remove()');
-                index = arguments[1];
-            }
-        }
-        else {
-            segments = parseAtSubpath(path, 1, 'Signal.remove()');
-            index = arguments[1];
-            howMany = arguments[2];
-        }
-        if (index == null && segments.length && typeof segments[segments.length - 1] === 'number') {
-            index = segments.pop();
-        }
+        if (arguments.length > 2)
+            throw Error('Signal.remove() expects zero to two arguments');
         if (typeof index !== 'number' || !Number.isFinite(index)) {
             throw Error('Signal.remove() expects a numeric index');
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayRemoveOnSignal($target, index, howMany);
+        return arrayRemoveOnSignal(this, index, howMany);
     }
-    async move(path, from, to, 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 > 4)
-            throw Error('Signal.move() expects two to four arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            from = arguments[0];
-            to = arguments[1];
-        }
-        else if (arguments.length === 3) {
-            if (typeof path === 'number') {
-                from = arguments[0];
-                to = arguments[1];
-                howMany = arguments[2];
-            }
-            else {
-                segments = parseAtSubpath(path, 1, 'Signal.move()');
-                from = arguments[1];
-                to = arguments[2];
-            }
-        }
-        else {
-            segments = parseAtSubpath(path, 1, 'Signal.move()');
-            from = arguments[1];
-            to = arguments[2];
-            howMany = arguments[3];
-        }
+        if (arguments.length > 3)
+            throw Error('Signal.move() expects two or three arguments');
         if (typeof from !== 'number' || !Number.isFinite(from) || typeof to !== 'number' || !Number.isFinite(to)) {
             throw Error('Signal.move() expects numeric from/to');
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        return arrayMoveOnSignal($target, from, to, howMany);
+        return arrayMoveOnSignal(this, from, to, howMany);
     }
-    async stringInsert(path, index, text) {
+    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 > 3)
-            throw Error('Signal.stringInsert() expects two or three arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            index = arguments[0];
-            text = arguments[1];
-        }
-        else {
-            segments = parseAtSubpath(path, 1, 'Signal.stringInsert()');
-            index = arguments[1];
-            text = arguments[2];
-        }
+        if (arguments.length > 2)
+            throw Error('Signal.stringInsert() expects two arguments');
         if (typeof index !== 'number' || !Number.isFinite(index)) {
             throw Error('Signal.stringInsert() expects a numeric index');
         }
-        const $target = resolveRelativePathTarget(this, segments);
-        return stringInsertOnSignal($target, index, text);
+        return stringInsertOnSignal(this, index, text);
     }
-    async stringRemove(path, index, howMany) {
+    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 > 3)
-            throw Error('Signal.stringRemove() expects two or three arguments');
-        let segments = [];
-        if (arguments.length === 2) {
-            index = arguments[0];
-            howMany = arguments[1];
-        }
-        else {
-            segments = parseAtSubpath(path, 1, 'Signal.stringRemove()');
-            index = arguments[1];
-            howMany = arguments[2];
-        }
+        if (arguments.length > 2)
+            throw Error('Signal.stringRemove() expects two arguments');
         if (typeof index !== 'number' || !Number.isFinite(index)) {
             throw Error('Signal.stringRemove() expects a numeric index');
         }
         if (howMany == null)
             howMany = 1;
-        const $target = resolveRelativePathTarget(this, segments);
-        return stringRemoveOnSignal($target, index, howMany);
+        return stringRemoveOnSignal(this, index, howMany);
     }
     async assign(value) {
         const forwarded = forwardRef(this, 'assign', arguments);
@@ -626,63 +421,50 @@ class SignalCompat extends Signal {
         return removeCustomEventListener(eventName, handler);
     }
     ref(path, target, options) {
-        if (arguments.length > 3)
-            throw Error('Signal.ref() expects one to three arguments');
-        let $from = this;
+        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 if (arguments.length === 2) {
-            if (isSignalLike(target) || typeof target === 'string') {
-                const segments = parseAtSubpath(path, 1, 'Signal.ref()');
-                $from = resolveSignal(this, segments);
-                $to = resolveRefTarget(this, target, 'Signal.ref()');
-            }
-            else {
-                $to = resolveRefTarget(this, path, 'Signal.ref()');
-                options = target;
-            }
-        }
         else {
-            const segments = parseAtSubpath(path, 1, 'Signal.ref()');
-            $from = resolveSignal(this, segments);
-            $to = resolveRefTarget(this, target, 'Signal.ref()');
+            $to = resolveRefTarget(this, path, 'Signal.ref()');
+            options = target;
         }
         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();
+        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($from, $to, { mirrorOnly, options });
+        const { stop, onChange } = createRefLink(this, $to, { mirrorOnly, options });
         store.set(fromPath, { stop });
-        const fromRootId = (getRoot($from) || $from)?.[ROOT_ID];
+        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
         const toRootId = (getRoot($to) || $to)?.[ROOT_ID];
         if (!mirrorOnly) {
-            $from[REF_TARGET] = $to;
-            setRefLink(fromRootId, fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], {
+            this[REF_TARGET] = $to;
+            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
                 mirrorOnly: false,
                 fromRootId,
                 toRootId
             });
         }
         else {
-            setRefLink(fromRootId, fromPath, $to.path(), $from[SEGMENTS], $to[SEGMENTS], {
+            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
                 mirrorOnly: true,
                 onChange,
                 fromRootId,
                 toRootId
             });
-            if ($from[REF_TARGET])
-                delete $from[REF_TARGET];
+            if (this[REF_TARGET])
+                delete this[REF_TARGET];
         }
-        return $from;
+        return this;
     }
     refExtra(path) {
         if (arguments.length !== 1)
@@ -707,40 +489,24 @@ class SignalCompat extends Signal {
         const $target = resolveSignal($root, segments);
         return SignalCompat.prototype.ref.call($target, this.ids);
     }
-    removeRef(path) {
-        if (arguments.length > 1)
-            throw Error('Signal.removeRef() expects a single argument');
-        let $from = this;
-        if (arguments.length === 1) {
-            const segments = parseAtSubpath(path, 1, 'Signal.removeRef()');
-            $from = resolveSignal(this, segments);
-        }
-        const store = getRefStore($from);
-        const fromPath = $from.path();
+    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($from) || $from)?.[ROOT_ID];
+        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
         removeRefLink(fromRootId, fromPath);
-        const $target = resolveRefSignal($from);
-        if ($target !== $from) {
-            setDiffDeepBypassRef($from, deepCopy($target.get()));
+        const $target = resolveRefSignal(this);
+        if ($target !== this) {
+            setDiffDeepBypassRef(this, deepCopy($target.get()));
         }
-        if ($from[REF_TARGET])
-            delete $from[REF_TARGET];
-    }
-    scope(path) {
-        const $root = getRoot(this) || this;
-        if (arguments.length === 0)
-            return $root;
-        const segments = arguments.length > 1
-            ? parseAtSegments(arguments, 'Signal.scope()')
-            : parseAtSubpath(path, arguments.length, 'Signal.scope()');
-        if (segments.length === 0)
-            return $root;
-        return resolveRelativePathTarget($root, segments);
+        if (this[REF_TARGET])
+            delete this[REF_TARGET];
     }
 }
 const SILENT_WRAPPER = Symbol('compat silent wrapper');
@@ -935,22 +701,6 @@ function parseAtSubpath(subpath, argsLength, methodName) {
         return [subpath];
     throw Error(`${methodName} expects a string or integer argument`);
 }
-function parseAtSegments(args, methodName) {
-    const segments = [];
-    for (const arg of Array.from(args)) {
-        if (typeof arg === 'string') {
-            const parts = arg.split('.').filter(Boolean);
-            segments.push(...parts);
-            continue;
-        }
-        if (typeof arg === 'number' && Number.isFinite(arg) && Number.isInteger(arg)) {
-            segments.push(arg);
-            continue;
-        }
-        throw Error(`${methodName} expects string or integer path segments`);
-    }
-    return segments;
-}
 function resolveSignal($signal, segments) {
     let $cursor = $signal;
     for (const segment of segments) {
@@ -958,24 +708,6 @@ function resolveSignal($signal, segments) {
     }
     return $cursor;
 }
-function resolveSignalWithRefs($signal, relativeSegments) {
-    const baseSegments = Array.isArray($signal?.[SEGMENTS]) ? $signal[SEGMENTS] : [];
-    const absoluteSegments = baseSegments.concat(relativeSegments);
-    const resolvedSegments = resolveRefSegmentsSafe(absoluteSegments, (getRoot($signal) || $signal)?.[ROOT_ID]);
-    if (!resolvedSegments)
-        return resolveSignal($signal, relativeSegments);
-    // Signals created through root functions can carry a raw root in [ROOT].
-    // For path-based ref writes we need proxy traversal semantics.
-    const $root = getRoot($signal) || $signal;
-    const $traversalRoot = getRoot($root) || $root;
-    return resolveSignal($traversalRoot, resolvedSegments);
-}
-function resolveRelativePathTarget($signal, relativeSegments) {
-    if (!Array.isArray(relativeSegments) || relativeSegments.length === 0) {
-        return resolveSignal($signal, []);
-    }
-    return resolveSignalWithRefs($signal, relativeSegments);
-}
 function isMissingPublicDocDeleteError($signal, error) {
     const segments = $signal?.[SEGMENTS];
     if (!Array.isArray(segments) || segments.length < 2)
@@ -1175,10 +907,6 @@ function deepEqualCompat(left, right) {
 function racerEqualCompat(left, right) {
     return left === right || (Number.isNaN(left) && Number.isNaN(right));
 }
-function getSignalValueAt($signal, segments) {
-    const $target = resolveRelativePathTarget($signal, segments);
-    return $target.get();
-}
 async function setReplaceOnSignal($signal, value) {
     const segments = $signal[SEGMENTS];
     if (segments.length === 0)

package/dist/orm/Signal.d.ts

@@ -4,8 +4,8 @@ export type { FromJsonSchema, InferZodSchema, JsonSchema, JsonSchemaObject, ZodL
 export type { ComputedQueryParamsInput, QueryParams, QueryParamsInput } from './types/query.js';
 export type { SignalArrayMutatorMethods, SignalArrayReaderMethods, SignalCollectionMethods, SignalMetadataMethods, SignalStringMutatorMethods, SignalValueMethods } from './types/baseMethods.js';
 export type { AppendPath, JoinPath, PathSegment, SignalPath, WildcardPathSegment, WildcardSignalPath } from './types/path.js';
-export type { AggregationSignal, AnySignal, ArraySignal, CollectionAggregationSignal, CollectionDocument, CollectionDocumentModel, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, DocumentSignal, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, PublicSignal, LocalSignalFactory, RegisteredAggregationInput, RuntimeSignalConstructor, RuntimeSignalInstance, QuerySignal, RootCollections, RootSignal, SignalBaseInstance, SignalChild, SignalChildren, SignalClass, SignalConstructor, SignalForKind, SignalKind, SignalInstance, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodSchemaSpec } from './types/signal.js';
-export type { CollectionsFromManifest, ModelEntry, ModelManifest, PathModelsFromManifest } from './types/modelManifest.js';
+export type { AggregationSignal, AnySignal, ArraySignal, CollectionAggregationSignal, CollectionDocument, CollectionDocumentModel, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, DocumentSignal, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, PublicSignal, LocalSignalFactory, RegisteredAggregationInput, RuntimeSignalConstructor, RuntimeSignalInstance, QuerySignal, RootCollections, RootSignal, SignalBaseInstance, SignalChild, SignalChildren, SignalClass, SignalConstructor, SignalForKind, SignalKind, SignalInstance, SignalModelConstructor, PrivateSignalFromSpec, RootPrivateCollections, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodSchemaSpec } from './types/signal.js';
+export type { CollectionsFromManifest, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest } from './types/modelManifest.js';
 export { Signal, SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS, regularBindings, extremelyLateBindings, isPublicCollectionSignal, isPublicDocumentSignal, isPublicCollection, isPrivateCollection } from './SignalBase.js';
 export { SignalCompat };
 declare const DefaultSignal: SignalConstructor;

package/dist/orm/SignalBase.d.ts

@@ -98,6 +98,11 @@ export declare class Signal<TValue = unknown> extends Function {
      * @param value New value to store at this signal path.
      */
     set(value: TValue): Promise<void>;
+    /**
+     * Replace this signal's value without deep-diffing object/array branches.
+     * @param value New value to store at this signal path.
+     */
+    setReplace(value: TValue): Promise<void>;
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.

package/dist/orm/SignalBase.js

@@ -13,14 +13,14 @@
  *    in the raw data tree which have the same name as signal's methods
  */
 import uuid from '@teamplay/utils/uuid';
-import { get as _get, setPublicDoc as _setPublicDoc, dataTreeRaw, getRaw, getLogicalRootSnapshot, incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from './dataTree.js';
+import { get as _get, setPublicDoc as _setPublicDoc, setPublicDocReplace as _setPublicDocReplace, del as _del, dataTreeRaw, getRaw, getLogicalRootSnapshot, incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from './dataTree.js';
 import getSignal, { rawSignal } from "./getSignal.js";
 import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
 import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
 import { ROOT_FUNCTION, ROOT_ID, getRoot } from "./Root.js";
 import { isPrivateMutationForbidden } from "./connection.js";
-import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, prepareAddPayload, resolveAddDocId } from "./idFields.js";
+import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, 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';
@@ -250,6 +250,42 @@ export class Signal extends Function {
             throw Error('Signal.set() expects a single argument');
         await setSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT, value);
     }
+    /**
+     * Replace this signal's value without deep-diffing object/array branches.
+     * @param value New value to store at this signal path.
+     */
+    async setReplace(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setReplace() expects a single argument');
+        const segments = this[SEGMENTS];
+        if (segments.length === 0)
+            throw Error('Can\'t set the root signal data');
+        const idFields = getIdFieldsForSegments(segments);
+        if (isIdFieldPath(segments, idFields))
+            return;
+        const nextValue = isPublicDocPath(segments)
+            ? normalizeIdFields(value, idFields, segments[1])
+            : value;
+        if (isPublicCollection(segments[0])) {
+            if (value === undefined) {
+                await _setPublicDoc(segments, nextValue);
+                if (segments.length === 2) {
+                    _del(segments);
+                }
+            }
+            else {
+                await _setPublicDocReplace(segments, nextValue);
+            }
+            return;
+        }
+        if (isPrivateMutationForbidden()) {
+            throw Error(`
+        Can't modify private collections data when 'publicOnly' is enabled.
+        On the server you can only work with public collections.
+      `);
+        }
+        setReplacePrivateData(getSignalOwningRootId(this), segments, nextValue);
+    }
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.
@@ -513,8 +549,9 @@ export const extremelyLateBindings = {
         if (segments[0] === AGGREGATIONS) {
             const aggregationDocId = getAggregationDocId(segments, getRoot(signal)?.[ROOT_ID]);
             if (aggregationDocId) {
-                if (segments.length === 3 && key === 'set')
+                if (segments.length === 3 && (key === 'set' || key === 'setReplace')) {
                     throw Error(ERRORS.setAggregationDoc(segments, key));
+                }
                 const collectionName = getAggregationCollectionName(segments);
                 const subDocSegments = segments.slice(3);
                 const $original = getSignal(getRoot(signal), [collectionName, aggregationDocId, ...subDocSegments]);

package/dist/orm/addModel.d.ts

@@ -1,6 +1,13 @@
 import type { SignalClass } from './Signal.js';
-import type { TeamplayModels } from '../index.js';
+import type { TeamplayModels, TeamplayPluginModels } from '../index.js';
 import type { PathSegment } from './types/path.js';
 export declare const MODELS: Record<string, SignalClass<any>>;
-export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof TeamplayModels ? TeamplayModels[TPattern] : SignalClass<any>): void;
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[TPattern] : SignalClass<any>): void;
 export declare function findModel(segments: PathSegment[]): SignalClass<any> | undefined;
+export {};

package/dist/orm/index.d.ts

@@ -1,6 +1,6 @@
 export { belongsTo, hasMany, hasOne } from './associations.js';
-export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, ComputedQueryParamsInput, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
-export type { RootSignal, TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../index.js';
+export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, ComputedQueryParamsInput, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest, PrivateSignalFromSpec, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, RootPrivateCollections, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
+export type { RootSignal, TeamplayCollections, TeamplayFeature, TeamplayFeatures, TeamplayModels, TeamplayPluginCollections, TeamplayPluginPrivateCollections, TeamplayPluginModels, TeamplayPluginOption, TeamplayPluginOptions, TeamplayPluginSignalFields, TeamplayPrivateCollections, TeamplaySignalFields } from '../index.js';
 export declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from './initModels.js';

package/dist/orm/types/baseMethods.d.ts

@@ -14,6 +14,7 @@ export interface SignalValueMethods<TValue> {
     get: () => TValue;
     peek: () => TValue;
     set: (value: TValue) => Promise<void>;
+    setReplace: (value: TValue) => Promise<void>;
     assign: (value: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never) => Promise<void>;
     del: () => Promise<void>;
     increment: (value?: number) => Promise<number>;

package/dist/orm/types/modelManifest.d.ts

@@ -1,5 +1,6 @@
 import type { Signal as BaseSignal } from '../SignalBase.js';
 import type { CollectionSpec, JsonSchemaSpec, SignalClass } from './signal.js';
+import type { FromJsonSchema } from './jsonSchema.js';
 export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>, TSchema = unknown> {
     default?: TModel;
     schema?: TSchema;
@@ -8,10 +9,14 @@ export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>,
 }
 export type ModelManifest = Record<string, ModelEntry>;
 type StringKey<TValue> = Extract<keyof TValue, string>;
-type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `_${string}` | `$${string}` ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type PrivateCollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey extends `_${string}` | `$${string}` ? TKey : never;
 type CollectionManifestKeys<TModels> = {
     [K in StringKey<TModels>]: CollectionManifestKey<K>;
 }[StringKey<TModels>];
+type PrivateCollectionManifestKeys<TModels> = {
+    [K in StringKey<TModels>]: PrivateCollectionManifestKey<K>;
+}[StringKey<TModels>];
 type ModelPathManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}*${string}` ? TKey : never;
 type ModelPathManifestKeys<TModels> = {
     [K in StringKey<TModels>]: ModelPathManifestKey<K>;
@@ -26,9 +31,15 @@ type SchemaFromEntry<TEntry> = TEntry extends {
 type CollectionSpecFromManifestEntry<TModels, TCollection extends string> = [
     SchemaFromEntry<ManifestEntry<TModels, TCollection>>
 ] extends [never] ? CollectionSpec<unknown, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>> : JsonSchemaSpec<SchemaFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>>;
+type PrivateCollectionValueFromManifestEntry<TModels, TCollection extends string> = [
+    SchemaFromEntry<ManifestEntry<TModels, TCollection>>
+] extends [never] ? unknown : FromJsonSchema<SchemaFromEntry<ManifestEntry<TModels, TCollection>>>;
 export type CollectionsFromManifest<TModels extends Record<string, any>> = {
     [K in CollectionManifestKeys<TModels>]: CollectionSpecFromManifestEntry<TModels, K>;
 };
+export type PrivateCollectionsFromManifest<TModels extends Record<string, any>> = {
+    [K in PrivateCollectionManifestKeys<TModels>]: PrivateCollectionValueFromManifestEntry<TModels, K>;
+};
 export type PathModelsFromManifest<TModels extends Record<string, any>> = {
     [K in ModelPathManifestKeys<TModels> as ManifestEntry<TModels, K> extends {
         default: any;

package/dist/orm/types/signal.d.ts

@@ -1,4 +1,4 @@
-import type { TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../../index.js';
+import type { TeamplayCollections, TeamplayPrivateCollections, TeamplayPluginPrivateCollections, TeamplayModels, TeamplayPluginCollections, TeamplayPluginModels, TeamplayPluginSignalFields, TeamplaySignalFields } from '../../index.js';
 import type { Signal, GETTERS } from '../SignalBase.js';
 import type { FromJsonSchema, InferZodSchema, JsonSchema, ZodLikeSchema } from './jsonSchema.js';
 import type { AppendPath, JoinPath, PathSegment, WildcardSignalPath } from './path.js';
@@ -20,11 +20,26 @@ type SignalQueryMethodKeys = SignalArrayReaderMethodKeys | SignalArrayMutatorMet
 type BlockedArrayMutators = {
     readonly [K in SignalArrayMutatorMethodKeys]?: never;
 };
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayCollections = TeamplayCollections & MergeRegistry<TeamplayPluginCollections>;
+type EffectiveTeamplayPrivateCollections = TeamplayPrivateCollections & MergeRegistry<TeamplayPluginPrivateCollections>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+type EffectiveTeamplaySignalFields = TeamplaySignalFields & MergeRegistry<TeamplayPluginSignalFields>;
+type RootDollarAliases = {
+    readonly session: '_session';
+    readonly page: '_page';
+    readonly render: '$render';
+    readonly system: '$system';
+};
 type SignalArrayLike<TItem> = SignalArrayReaderMethods<TItem>;
-type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplayModels ? TeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? TeamplayModels[JoinPath<TPath>] : TeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? TeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
+type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? EffectiveTeamplayModels[JoinPath<TPath>] : EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? EffectiveTeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
 type ArrayItemSignal<Item, TPath extends WildcardSignalPath> = DocumentSignal<Item, typeof Signal, AppendPath<TPath, '*'>>;
 type SignalArrayMethods<TValue, TPath extends WildcardSignalPath> = NonNullable<TValue> extends ReadonlyArray<infer Item> ? SignalArrayLike<ArrayItemSignal<Item, TPath>> : Pick<Signal<TValue>, SignalArrayReaderMethodKeys>;
-type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplaySignalFields ? TeamplaySignalFields[JoinPath<TPath>] : {};
+type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplaySignalFields ? EffectiveTeamplaySignalFields[JoinPath<TPath>] : {};
 type DocumentSignalIdMethod = {
     getId: () => string;
 };
@@ -62,22 +77,22 @@ export type CollectionDocument<TSpec> = TSpec extends CollectionSpec<infer Docum
 export type CollectionDocumentModel<TSpec> = TSpec extends CollectionSpec<any, any, infer DocumentModel> ? DocumentModel : typeof Signal;
 export type CollectionQuerySignal<TDocument, TCollectionModel extends SignalClass<any>, TDocumentModel extends SignalClass<any>, TCollectionPath extends WildcardSignalPath> = CollectionSignalForKind<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> & QueryMetadataSignals;
 type MatchingDocumentCollectionKeys<TValue> = IsAny<TValue> extends true ? never : {
-    [K in keyof TeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<TeamplayCollections[K]>>> extends true ? K : never;
-}[keyof TeamplayCollections & string];
+    [K in keyof EffectiveTeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<EffectiveTeamplayCollections[K]>>> extends true ? K : never;
+}[keyof EffectiveTeamplayCollections & string];
 type MatchingCollectionKeys<TValue> = IsAny<TValue> extends true ? never : NonNullable<TValue> extends ReadonlyArray<infer TDocument> ? MatchingDocumentCollectionKeys<TDocument> : never;
 type SingleDocumentCollectionKey<TValue> = SingleKey<MatchingDocumentCollectionKeys<TValue>>;
 type SingleCollectionKey<TValue> = SingleKey<MatchingCollectionKeys<TValue>>;
 type DocumentSignalModelForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? CollectionDocumentModel<TeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
+] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? CollectionDocumentModel<EffectiveTeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
 type DocumentSignalPathForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
+] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
 type SignalForDocumentValue<TValue> = TypedSignal<TValue, DocumentSignalModelForValue<TValue>, DocumentSignalPathForValue<TValue>>;
-type SignalForCollectionArrayValue<TCollection extends keyof TeamplayCollections & string> = CollectionSignal<CollectionDocument<TeamplayCollections[TCollection]>, TeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection]>;
+type SignalForCollectionArrayValue<TCollection extends keyof EffectiveTeamplayCollections & string> = CollectionSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, EffectiveTeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection]>;
 type SignalForArrayValue<TValue> = [
     SingleCollectionKey<TValue>
-] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof TeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
+] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
 export type PublicSignal<TValue = unknown> = IsAny<TValue> extends true ? TypedSignal<TValue> : NonNullable<TValue> extends ReadonlyArray<any> ? SignalForArrayValue<TValue> : SignalForDocumentValue<TValue>;
 export interface LocalSignalFactory {
     (): any;
@@ -85,12 +100,12 @@ export interface LocalSignalFactory {
     <TValue>(factory: () => TValue): TypedSignal<TValue>;
     <TValue>(value: TValue): TypedSignal<TValue>;
 }
-export type RootCollections<TCollections extends Record<string, any> = TeamplayCollections> = {
+export type RootCollections<TCollections = EffectiveTeamplayCollections> = {
     readonly [K in keyof TCollections & string]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 } & {
     readonly [K in keyof TCollections & string as `$${K}`]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 };
-export type RootSignal<TCollections extends Record<string, any> = TeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections>;
+export type RootSignal<TCollections = EffectiveTeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections> & RootPrivateCollections;
 export interface RegisteredAggregationInput<TCollection extends string = string, TOutput = unknown> {
     readonly __isAggregation: true;
     readonly collection: TCollection;
@@ -101,10 +116,10 @@ export interface TypedAggregationInput<TDocument = unknown, TDocumentModel exten
     readonly __teamplayDocument?: TDocument;
     readonly __teamplayDocumentModel?: TDocumentModel;
 }
-export type CollectionAggregationSignal<TCollection extends keyof TeamplayCollections & string> = AggregationSignal<CollectionDocument<TeamplayCollections[TCollection]>, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
+export type CollectionAggregationSignal<TCollection extends keyof EffectiveTeamplayCollections & string> = AggregationSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
 export type TypedAggregationSignal<TDocument, TDocumentModel extends SignalClass<any>> = AggregationSignal<TDocument, TDocumentModel>;
 export type AggregationOutputSignal<TOutput> = IsAny<TOutput> extends true ? QuerySignal : NonNullable<TOutput> extends ReadonlyArray<infer TDocument> ? AggregationSignal<TDocument, DocumentSignalModelForValue<TDocument>, DocumentSignalPathForValue<TDocument>> : SignalForDocumentValue<TOutput>;
-type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof TeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
+type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof EffectiveTeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
 export type MaybePromise<TValue> = TValue | Promise<TValue>;
 export type SubResult<TSignal, TParams = undefined> = TSignal extends ClientAggregationFunction<infer TOutput, infer TCollection> ? RegisteredAggregationSignal<TCollection, TOutput> : TSignal extends AggregationFunction<infer TOutput, any> ? IsUnknown<TOutput> extends true ? QuerySignal : AggregationOutputSignal<TOutput> : TSignal extends TypedAggregationInput<infer TDocument, infer TDocumentModel> ? TypedAggregationSignal<TDocument, TDocumentModel> : TSignal extends RegisteredAggregationInput<infer TCollection, infer TOutput> ? RegisteredAggregationSignal<TCollection, TOutput> : [TParams] extends [undefined] ? TSignal extends DocumentSignal<any, any, any> ? TSignal : QuerySignal : TSignal extends CollectionSignal<infer TDocument, infer TCollectionModel, infer TDocumentModel, infer TCollectionPath> ? CollectionQuerySignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> : QuerySignal;
 export type MaybePromiseSubResult<TSignal, TParams = undefined> = MaybePromise<SubResult<TSignal, TParams>>;
@@ -124,6 +139,17 @@ export interface CollectionSpec<TDocument = unknown, TCollectionModel extends Si
 export type JsonSchemaSpec<TSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<FromJsonSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type ZodSchemaSpec<TSchema extends ZodLikeSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<InferZodSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type CollectionSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = TSpec extends CollectionSpec<infer Document, infer CollectionModel, infer DocumentModel> ? CollectionSignal<Document, CollectionModel, DocumentModel, TPath> : TSpec extends JsonSchema ? CollectionSignal<FromJsonSchema<TSpec>, typeof Signal, typeof Signal, TPath> : CollectionSignal;
+export type PrivateSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = Omit<DocumentSignal<TSpec, typeof Signal, TPath>, 'add'>;
+type PrivateSignalForAlias<TPrivateCollections, TAlias extends keyof RootDollarAliases & string> = RootDollarAliases[TAlias] extends keyof TPrivateCollections & string ? PrivateSignalFromSpec<TPrivateCollections[RootDollarAliases[TAlias]], readonly [RootDollarAliases[TAlias]]> : never;
+export type RootPrivateCollections<TPrivateCollections = EffectiveTeamplayPrivateCollections> = {
+    readonly [K in keyof TPrivateCollections & string]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof TPrivateCollections & string as `$${K}`]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? K : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? `$${K}` : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+};
 export interface SignalConstructor {
     new <TValue = unknown>(segments: PathSegment[]): TypedSignal<TValue>;
     readonly ID_FIELDS: typeof Signal.ID_FIELDS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.4",
+  "version": "0.5.0-alpha.7",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -69,13 +69,13 @@
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
     "@startupjs/sharedb-mingo-memory": "^4.0.0-2",
-    "@teamplay/backend": "^0.5.0-alpha.1",
-    "@teamplay/cache": "^0.5.0-alpha.0",
-    "@teamplay/channel": "^0.5.0-alpha.0",
-    "@teamplay/debug": "^0.5.0-alpha.0",
-    "@teamplay/schema": "^0.5.0-alpha.1",
-    "@teamplay/utils": "^0.5.0-alpha.0",
-    "babel-plugin-teamplay": "^0.5.0-alpha.1",
+    "@teamplay/backend": "^0.5.0-alpha.7",
+    "@teamplay/cache": "^0.5.0-alpha.7",
+    "@teamplay/channel": "^0.5.0-alpha.7",
+    "@teamplay/debug": "^0.5.0-alpha.7",
+    "@teamplay/schema": "^0.5.0-alpha.7",
+    "@teamplay/utils": "^0.5.0-alpha.7",
+    "babel-plugin-teamplay": "^0.5.0-alpha.7",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
@@ -116,6 +116,12 @@
     "transform": {
       "^.+\\.ts$": "./test/ts-transform.cjs"
     },
+    "testEnvironmentOptions": {
+      "customExportConditions": [
+        "teamplay-ts",
+        "browser"
+      ]
+    },
     "extensionsToTreatAsEsm": [
       ".ts"
     ],
@@ -128,5 +134,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "7ec37caa078961926442b1aba74768792359c2c2"
+  "gitHead": "a854bf3447232cd732ec55e6a3faf57b094e99d1"
 }