@ng-org/alien-deepsignals 0.1.2-alpha.2 → 0.1.2-alpha.4

package/dist/deepSignal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepSignal.d.ts","sourceRoot":"","sources":["../src/deepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAGH,sBAAsB,EACtB,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EAMpB,MAAM,SAAS,CAAC;AAi/BjB,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAwBf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,EAChD,gBAAgB,GAAE,OAAe,GAClC,MAAM,IAAI,CAoBZ;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,GAAG,SAAS,CAIpB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAGnD;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,QAGtE;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAa1E"}
+{"version":3,"file":"deepSignal.d.ts","sourceRoot":"","sources":["../src/deepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAGH,sBAAsB,EACtB,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EAMpB,MAAM,SAAS,CAAC;AA+qCjB,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAwBf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,EAChD,gBAAgB,GAAE,OAAe,GAClC,MAAM,IAAI,CAoBZ;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,GAAG,SAAS,CAIpB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAGnD;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,QAItE;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAa1E"}

package/dist/deepSignal.js

@@ -19,9 +19,11 @@ exports.setSetEntrySyntheticId = setSetEntrySyntheticId;
 exports.addWithId = addWithId;
 const core_1 = require("./core");
 const iteratorHelpers_1 = require("./iteratorHelpers");
+/** The current proxy object for the raw object (others might exist but are not the current / clean ones). */
 const rawToProxy = new WeakMap();
-const proxyToMeta = new WeakMap();
-const proxySignals = new WeakMap();
+const rawToMeta = new WeakMap();
+// TODO: We can move them to the meta objects.
+const propertiesToSignals = new WeakMap();
 const iterableSignals = new WeakMap();
 const ignored = new WeakSet();
 const rootStates = new Map();
@@ -29,6 +31,7 @@ const pendingRoots = new Set();
 const supported = new Set([Object, Array, Set]);
 const descriptor = Object.getOwnPropertyDescriptor;
 let blankNodeCounter = 0;
+let tmpIdCounter = 0;
 const wellKnownSymbols = new Set([
     Symbol.asyncDispose,
     Symbol.asyncIterator,
@@ -51,37 +54,20 @@ const forcedSyntheticIds = new WeakMap();
 const META_KEY = "__meta__";
 const RAW_KEY = "__raw__";
 const DEFAULT_SYNTHETIC_ID_PROPERTY_NAME = "@id";
-/**
- * Lookup the metadata record backing a proxy (if the value is proxied).
- * Returns undefined for non-object inputs or values that never went through deepSignal().
- */
-function getMeta(target) {
-    if (!target || typeof target !== "object")
-        return undefined;
-    return proxyToMeta.get(target);
-}
-/**
- * Resolve the raw underlying object for a possibly proxied value.
- * Falls back to the value itself when no proxy metadata is attached.
- */
-function getRaw(value) {
-    const meta = getMeta(value);
-    return meta?.raw ?? value;
-}
 /** Returns `true` if `value` is an object, array or set and is not in `ignored`. */
 function shouldProxy(value) {
     return (!!value &&
         typeof value === "object" &&
-        supported.has(value.constructor) &&
+        (supported.has(value.constructor) || value instanceof Set) &&
         !ignored.has(value));
 }
 /**
  * Get or create the map in `proxySignals` for key `proxy`.
  */
-function ensureSignalMap(proxy) {
-    if (!proxySignals.has(proxy))
-        proxySignals.set(proxy, new Map());
-    return proxySignals.get(proxy);
+function ensureSignalMap(rawObj) {
+    if (!propertiesToSignals.has(rawObj))
+        propertiesToSignals.set(rawObj, new Map());
+    return propertiesToSignals.get(rawObj);
 }
 /**
  * Write a new value into a cached signal, creating it if needed.
@@ -134,6 +120,20 @@ function escapePathSegment(segment) {
 function isReactiveSymbol(key) {
     return typeof key === "symbol" && !wellKnownSymbols.has(key);
 }
+/**
+ * Replaces the old proxy to a raw object with a new one.
+ * Used so that we can indicate modifications along the path of a change by equality checks.
+ */
+function replaceProxy(meta) {
+    if (!meta.parent || !meta.key)
+        return;
+    // Create a new proxy for this raw object -- frontend libs like react need this to recognize changes along this path.
+    const handlers = meta.raw instanceof Set ? setHandlers : objectHandlers;
+    const proxy = new Proxy(meta.raw, handlers);
+    rawToProxy.set(meta.raw, proxy);
+    const signal = propertiesToSignals.get(meta.parent.raw)?.get(meta.key);
+    signal?.(proxy);
+}
 /**
  * Walk the metadata chain to build the patch path for a property access.
  * Handles numbers, symbols (using description) and synthetic ID markers.
@@ -160,7 +160,8 @@ function buildPath(meta, key, skipEscape = false) {
     let cursor = meta;
     while (cursor && cursor.parent && cursor.key !== undefined) {
         push(cursor.key, !!cursor.isSyntheticId);
-        cursor = getMeta(cursor.parent);
+        replaceProxy(cursor);
+        cursor = cursor.parent;
     }
     return path;
 }
@@ -168,8 +169,8 @@ function buildPath(meta, key, skipEscape = false) {
 function resolveContainerPath(meta) {
     if (!meta || !meta.parent || meta.key === undefined)
         return [];
-    const parentMeta = getMeta(meta.parent);
-    return buildPath(parentMeta, meta.key, !!meta.isSyntheticId);
+    replaceProxy(meta);
+    return buildPath(meta.parent, meta.key, !!meta.isSyntheticId);
 }
 /**
  * Build and enqueue patches for a mutation, only if listeners exist on the root.
@@ -297,24 +298,25 @@ function initializeObjectTreeIfNoListeners(meta, basePath, value, inSet) {
  * Does not proxy and returns `value` if @see shouldProxy returns false.
  * Returns value if parent has no metadata record.
  */
-function ensureChildProxy(value, parentProxy, key, isSyntheticId = false) {
-    if (!shouldProxy(value))
-        return value;
-    if (rawToProxy.has(value)) {
-        const proxied = rawToProxy.get(value);
-        const proxiedMeta = getMeta(proxied);
+function ensureChildProxy(rawChild, parent, key, isSyntheticId = false) {
+    if (!shouldProxy(rawChild))
+        return rawChild;
+    const parentRaw = parent[RAW_KEY] || parent;
+    const parentMeta = rawToMeta?.get(parentRaw);
+    if (rawToProxy.has(rawChild)) {
+        const proxied = rawToProxy.get(rawChild);
+        const proxiedMeta = rawToMeta.get(rawChild);
         if (proxiedMeta) {
-            proxiedMeta.parent = parentProxy;
+            proxiedMeta.parent = parentMeta;
             proxiedMeta.key = key;
             proxiedMeta.isSyntheticId = isSyntheticId;
         }
         return proxied;
     }
-    const parentMeta = getMeta(parentProxy);
     if (!parentMeta)
-        return value;
+        return rawChild;
     // Create proxy if none exists yet.
-    const proxy = createProxy(value, parentMeta.root, parentMeta.options, parentProxy, key, isSyntheticId);
+    const proxy = createProxy(rawChild, parentMeta.root, parentMeta.options, parentMeta, key, isSyntheticId);
     return proxy;
 }
 /**
@@ -338,7 +340,7 @@ function ensureSetInfo(meta) {
  * - Add object and id to `idForObject` and `objectForId` maps.
  */
 function assignSyntheticId(meta, entry, path, inSet) {
-    const rawEntry = getRaw(entry);
+    const rawEntry = entry?.[RAW_KEY] ?? entry;
     if (!rawEntry || typeof rawEntry !== "object") {
         return rawEntry;
     }
@@ -397,30 +399,22 @@ function assignSyntheticId(meta, entry, path, inSet) {
     return idString;
 }
 /** Create the appropriate proxy (object vs Set) and track its metadata. */
-function createProxy(target, root, options, parent, key, isSyntheticId) {
+function createProxy(target, root, options, parentMeta, key, isSyntheticId) {
     const handlers = target instanceof Set ? setHandlers : objectHandlers;
     const proxy = new Proxy(target, handlers);
     const meta = {
         raw: target,
-        parent,
+        parent: parentMeta,
         key,
         isSyntheticId,
         root,
         options,
     };
-    proxyToMeta.set(proxy, meta);
-    proxySignals.set(proxy, new Map());
+    propertiesToSignals.set(target, new Map());
+    rawToMeta.set(target, meta);
     rawToProxy.set(target, proxy);
     return proxy;
 }
-/** Normalize a value prior to writes, ensuring nested objects are proxied. */
-function ensureValueForWrite(value, receiver, key) {
-    const rawValue = getRaw(value);
-    const proxied = shouldProxy(rawValue)
-        ? ensureChildProxy(rawValue, receiver, key)
-        : rawValue;
-    return { raw: rawValue, proxied };
-}
 /** Return primitive literals (string/number/boolean) for patch serialization. */
 function snapshotLiteral(value) {
     if (typeof value === "string" ||
@@ -453,8 +447,8 @@ function emitPatchesForNew(value, meta, basePath, inSet = false) {
         {
             path: basePath,
             op: "add",
-            type: value instanceof Set ? "set" : "object",
-            value: value instanceof Set ? [] : undefined,
+            value: value instanceof Set || Array.isArray(value) ? [] : {},
+            type: value instanceof Set ? "set" : undefined,
         },
     ];
     // The id property name, usually `@id`
@@ -508,14 +502,136 @@ function emitPatchesForNew(value, meta, basePath, inSet = false) {
     }
     return patches;
 }
+/**
+ * Refresh numeric index signals for an array target so reads return current items
+ * and dependent effects are notified. Recreates/proxies values for indices < length
+ * and clears signals for indices >= length.
+ */
+function refreshNumericIndexSignals(target, receiver) {
+    const sigs = propertiesToSignals.get(target);
+    if (!sigs)
+        return;
+    for (const k of Array.from(sigs.keys())) {
+        if (typeof k === "string" && /^\d+$/.test(k)) {
+            const idx = Number(k);
+            if (idx >= target.length) {
+                const existing = sigs.get(k);
+                if (existing &&
+                    typeof existing.set === "function") {
+                    existing.set(undefined);
+                }
+                sigs.delete(k);
+            }
+            else {
+                const val = target[idx];
+                const proxied = ensureChildProxy(val, receiver, idx);
+                setSignalValue(sigs, k, proxied);
+            }
+        }
+    }
+}
+let hasWarnedAboutMissingSupportForReverse = false;
+let hasWarnedAboutMissingSupportForSort = false;
+/** Returns proxy function for array-mutating functions. */
+const getArrayMutationProxy = (target, key, receiver) => {
+    const meta = rawToMeta.get(target);
+    if (key === "reverse") {
+        if (!hasWarnedAboutMissingSupportForReverse) {
+            console.warn(".reverse() was called on deepSignal array. In place modifications with .sort() and .reverse() are not supported. `toReversed` will be called instead.");
+            hasWarnedAboutMissingSupportForReverse = true;
+        }
+        return target.toReversed;
+    }
+    else if (key === "sort") {
+        if (!hasWarnedAboutMissingSupportForSort) {
+            console.warn(".sort() was called on deepSignal array. In place modifications with .sort() and .reverse() are not supported. `toSorted` will be called instead.");
+            hasWarnedAboutMissingSupportForSort = true;
+        }
+        return target.toSorted;
+    }
+    else if (key === "shift") {
+        return () => {
+            target.shift();
+            schedulePatch(meta, () => ({
+                op: "remove",
+                path: buildPath(meta, "0"),
+            }));
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+        };
+    }
+    else if (key === "splice") {
+        return (start, deleteCount, ...items) => {
+            // Call splice on (non-proxied) target.
+            const deletedItems = target.splice(start, deleteCount, ...items);
+            // Manually schedule patches.
+            schedulePatch(meta, () => {
+                const patches = [];
+                // All items can be deleted at the same path / index.
+                for (let i = 0; i < deleteCount; i++) {
+                    patches.push({
+                        op: "remove",
+                        path: buildPath(meta, String(start)),
+                    });
+                }
+                // All items can be inserted at same path / index, by adding items in reverse order.
+                for (const newItem of items.toReversed()) {
+                    patches.push({
+                        op: "add",
+                        path: buildPath(meta, String(start)),
+                        value: newItem,
+                    });
+                }
+                return patches;
+            });
+            // Ensure newly added items are proxied.
+            for (let i = 0; i < items.length; i++) {
+                ensureChildProxy(items[i], target, start + i);
+            }
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            return deletedItems;
+        };
+    }
+    else if (key === "unshift") {
+        return (...items) => {
+            const deletedItems = target.unshift(...items);
+            schedulePatch(meta, () => {
+                const patches = [];
+                // All items can be inserted at index 0, by adding items in reverse order.
+                for (const newItem of items.toReversed()) {
+                    patches.push({
+                        op: "add",
+                        path: buildPath(meta, "0"),
+                        value: newItem,
+                    });
+                }
+                return patches;
+            });
+            // Ensure newly added items are proxied.
+            for (let i = 0; i < items.length; i++) {
+                ensureChildProxy(items[i], target, i);
+            }
+            // Update length of proxy explicitly.
+            receiver.length = target.length;
+            // Refresh numeric index signals so shifted indices don't return stale values.
+            refreshNumericIndexSignals(target, receiver);
+            return deletedItems;
+        };
+    }
+};
 /** Proxy handler driving reactivity for plain objects and arrays. */
 const objectHandlers = {
     get(target, key, receiver) {
         // Handle meta keys
         if (key === RAW_KEY)
-            return getMeta(receiver)?.raw ?? target;
+            return target;
         if (key === META_KEY)
-            return getMeta(receiver);
+            return rawToMeta.get(target);
         // TODO: Why are we doing this?
         if (typeof key === "symbol") {
             if (key === Symbol.iterator) {
@@ -525,20 +641,25 @@ const objectHandlers = {
             if (!isReactiveSymbol(key))
                 return Reflect.get(target, key, receiver);
         }
+        // Array helper handling. We need that because otherwise, every array position change would go as a separate operation through the proxy.
+        // Thus, we need to schedule the patches manually for mutating array functions.
+        if (Array.isArray(target)) {
+            const mutationProxy = getArrayMutationProxy(target, key, receiver);
+            if (mutationProxy) {
+                return mutationProxy;
+            }
+        }
         // Get object map from key to signal.
-        const signals = ensureSignalMap(receiver);
-        // TODO: Why are we doing this?
+        const signals = ensureSignalMap(target);
         // Ensure that target object is signal.
         ensureComputed(signals, target, key, receiver);
         // Add signal if it does not exist already and did not have a getter.
         if (!signals.has(key)) {
-            let rawValue = Reflect.get(target, key, receiver);
-            if (typeof rawValue === "function")
-                return rawValue.bind(receiver ?? target);
-            rawValue = shouldProxy(rawValue)
-                ? ensureChildProxy(rawValue, receiver, key)
-                : rawValue;
-            signals.set(key, (0, core_1.signal)(rawValue));
+            let rawChild = Reflect.get(target, key, receiver);
+            if (typeof rawChild === "function")
+                return rawChild.bind(receiver ?? target);
+            const childProxyOrRaw = ensureChildProxy(rawChild, receiver, key);
+            signals.set(key, (0, core_1.signal)(childProxyOrRaw));
         }
         // Call and return signal
         const sig = signals.get(key);
@@ -548,7 +669,7 @@ const objectHandlers = {
         // Skip reactivity for symbols.
         if (typeof key === "symbol" && !isReactiveSymbol(key))
             return Reflect.set(target, key, value, receiver);
-        const meta = getMeta(receiver);
+        const meta = rawToMeta.get(target);
         if (meta?.options?.readOnlyProps?.includes(String(key))) {
             throw new Error(`Cannot modify readonly property '${String(key)}'`);
         }
@@ -556,30 +677,56 @@ const objectHandlers = {
         const desc = descriptor(target, key);
         const hasAccessor = !!desc &&
             (typeof desc.get === "function" || typeof desc.set === "function");
-        const { raw, proxied } = ensureValueForWrite(value, receiver, key);
+        const proxied = ensureChildProxy(value, target, key);
+        const rawValue = value?.[RAW_KEY] ?? value;
         const hadKey = Object.prototype.hasOwnProperty.call(target, key);
-        const previous = hadKey ? target[key] : undefined;
-        const result = Reflect.set(target, key, raw, receiver);
+        const shouldManuallyTrimLength = Array.isArray(target) && key === "length" && value < target.length;
+        // If `length` is used to reduce the size of the array, delete the overflowing slots
+        // manually so that existing delete reactivity emits the patches and clears signals.
+        if (shouldManuallyTrimLength) {
+            for (let i = target.length - 1; i >= value; i -= 1) {
+                delete receiver[i];
+            }
+        }
+        // === Set value on actual target ===
+        const result = Reflect.set(target, key, rawValue, receiver);
         if (!hasAccessor) {
-            const signals = ensureSignalMap(receiver);
+            const signals = ensureSignalMap(target);
             setSignalValue(signals, key, proxied);
         }
         if (!hadKey)
             touchIterable(target);
-        if (meta && path && typeof raw === "object") {
-            initializeObjectTreeIfNoListeners(meta, path, raw, false);
+        if (meta && path && typeof rawValue === "object") {
+            initializeObjectTreeIfNoListeners(meta, path, rawValue, false);
+        }
+        // Modifications to the length should not emit patches
+        if (Array.isArray(target) && key === "length") {
+            return result;
         }
         schedulePatch(meta, () => {
             const resolvedPath = path ?? buildPath(meta, key);
-            if (!hadKey || typeof raw === "object") {
-                return emitPatchesForNew(raw, meta, resolvedPath);
+            if (!hadKey || typeof rawValue === "object") {
+                const patches = emitPatchesForNew(rawValue, meta, resolvedPath);
+                // TODO: Document
+                // If an object is added to an array (this happens in discrete CRDTs), we will eventually receive an @id back.
+                // However, the @id is not available from the beginning but frontend frameworks might depend on @id.
+                // Thus, we set a temporary @id which will be replaced once we are called back with the real @id.
+                // Also, we don't emit a patch for this.
+                if (Array.isArray(target) &&
+                    !isNaN(Number(key)) &&
+                    value &&
+                    typeof value === "object" &&
+                    meta?.options.syntheticIdPropertyName !== "@id") {
+                    rawValue["@id"] = `tmp-${++tmpIdCounter}`;
+                }
+                return patches;
             }
-            if (snapshotLiteral(raw) === undefined)
+            if (snapshotLiteral(rawValue) === undefined)
                 return undefined;
             return {
                 path: resolvedPath,
                 op: "add",
-                value: raw,
+                value: rawValue,
             };
         });
         return result;
@@ -587,13 +734,13 @@ const objectHandlers = {
     deleteProperty(target, key) {
         if (typeof key === "symbol" && !isReactiveSymbol(key))
             return Reflect.deleteProperty(target, key);
-        const receiver = rawToProxy.get(target);
-        const meta = receiver ? getMeta(receiver) : undefined;
+        const meta = rawToMeta.get(target);
         const hadKey = Object.prototype.hasOwnProperty.call(target, key);
         const result = Reflect.deleteProperty(target, key);
         if (hadKey) {
-            if (receiver && proxySignals.has(receiver)) {
-                const signals = proxySignals.get(receiver);
+            if (propertiesToSignals.has(target)) {
+                // Trigger signal
+                const signals = propertiesToSignals.get(target);
                 const existing = signals.get(key);
                 if (existing &&
                     typeof existing.set === "function") {
@@ -601,6 +748,7 @@ const objectHandlers = {
                 }
                 signals.delete(key);
             }
+            // Notify listeners
             touchIterable(target);
             schedulePatch(meta, () => ({
                 path: buildPath(meta, key),
@@ -618,9 +766,9 @@ const objectHandlers = {
 /**
  * Guarantee Set iteration always surfaces proxies, even when raw values were stored.
  */
-function ensureEntryProxy(receiver, entry, syntheticKey, meta) {
+function ensureEntryProxy(raw, entry, syntheticKey, meta) {
     return shouldProxy(entry)
-        ? ensureChildProxy(entry, receiver, syntheticKey, true)
+        ? ensureChildProxy(entry, raw, syntheticKey, true)
         : entry;
 }
 /** Wrap the underlying Set iterator so each value is proxied before leaving the trap. */
@@ -632,8 +780,8 @@ function createSetIterator(target, receiver, mapValue) {
         const next = iterator.next();
         if (next.done)
             return next;
-        const meta = getMeta(receiver);
-        const proxied = ensureEntryProxy(receiver, next.value, assignSyntheticId(meta, next.value, [], true), meta);
+        const meta = rawToMeta.get(target);
+        const proxied = ensureEntryProxy(target, next.value, assignSyntheticId(meta, next.value, [], true), meta);
         return {
             value: mapValue(proxied),
             done: false,
@@ -643,10 +791,11 @@ function createSetIterator(target, receiver, mapValue) {
 /** Proxy handler providing deep-signal semantics for native Set instances. */
 const setHandlers = {
     get(target, key, receiver) {
+        const meta = rawToMeta.get(target);
         if (key === RAW_KEY)
-            return getMeta(receiver)?.raw ?? target;
+            return target;
         if (key === META_KEY)
-            return getMeta(receiver);
+            return meta;
         if (key === "size") {
             const sig = ensureIterableSignal(target);
             sig();
@@ -659,21 +808,19 @@ const setHandlers = {
                 const iterator = target.values().next();
                 if (iterator.done)
                     return undefined;
-                const meta = getMeta(receiver);
-                return ensureEntryProxy(receiver, iterator.value, assignSyntheticId(meta, iterator.value, [], true), meta);
+                return ensureEntryProxy(target, iterator.value, assignSyntheticId(meta, iterator.value, [], true), meta);
             };
         }
         if (key === "getById") {
             return function getById(id) {
                 const iterableSig = ensureIterableSignal(target);
                 iterableSig();
-                const meta = getMeta(receiver);
                 if (!meta?.setInfo)
                     return undefined;
                 const entry = meta.setInfo.objectForId.get(String(id));
                 if (!entry)
                     return undefined;
-                return ensureEntryProxy(receiver, entry, String(id), meta);
+                return ensureEntryProxy(target, entry, String(id), meta);
             };
         }
         if (key === "getBy") {
@@ -685,9 +832,8 @@ const setHandlers = {
         }
         if (key === "add") {
             return function add(value) {
-                const meta = getMeta(receiver);
                 const containerPath = resolveContainerPath(meta);
-                const rawValue = getRaw(value);
+                const rawValue = value[RAW_KEY] ?? value;
                 const sizeBefore = target.size;
                 const result = target.add(rawValue);
                 if (target.size !== sizeBefore) {
@@ -695,7 +841,7 @@ const setHandlers = {
                     if (rawValue && typeof rawValue === "object") {
                         const synthetic = assignSyntheticId(meta, rawValue, containerPath, true);
                         initializeObjectTreeIfNoListeners(meta, [...containerPath, synthetic], rawValue, true);
-                        ensureEntryProxy(receiver, rawValue, synthetic, meta);
+                        ensureEntryProxy(target, rawValue, synthetic, meta);
                         schedulePatch(meta, () => emitPatchesForNew(rawValue, meta, [...containerPath, synthetic], true));
                     }
                     else {
@@ -715,9 +861,8 @@ const setHandlers = {
         }
         if (key === "delete") {
             return function deleteEntry(value) {
-                const meta = getMeta(receiver);
                 const containerPath = resolveContainerPath(meta);
-                const rawValue = getRaw(value);
+                const rawValue = value?.[RAW_KEY] ?? value;
                 const synthetic = rawValue && typeof rawValue === "object"
                     ? ensureSetInfo(meta).idForObject.get(rawValue)
                     : rawValue;
@@ -748,7 +893,6 @@ const setHandlers = {
         }
         if (key === "clear") {
             return function clear() {
-                const meta = getMeta(receiver);
                 const containerPath = resolveContainerPath(meta);
                 if (meta.setInfo) {
                     meta.setInfo.objectForId.clear();
@@ -796,12 +940,11 @@ const setHandlers = {
             return function forEach(callback, thisArg) {
                 const iterableSig = ensureIterableSignal(target);
                 iterableSig();
-                const meta = getMeta(receiver);
                 let index = 0;
                 const expectsIteratorSignature = callback.length <= 2;
                 const iteratorCallback = callback;
                 target.forEach((entry) => {
-                    const proxied = ensureEntryProxy(receiver, entry, assignSyntheticId(meta, entry, [], true), meta);
+                    const proxied = ensureEntryProxy(target, entry, assignSyntheticId(meta, entry, [], true), meta);
                     if (expectsIteratorSignature) {
                         iteratorCallback.call(thisArg, proxied, index++);
                     }
@@ -813,7 +956,7 @@ const setHandlers = {
         }
         if (key === "has") {
             return function has(value) {
-                return target.has(getRaw(value));
+                return target.has(value?.[RAW_KEY] ?? value);
             };
         }
         return Reflect.get(target, key, receiver);
@@ -821,7 +964,7 @@ const setHandlers = {
 };
 /** Runtime guard that checks whether a value is a deepSignal proxy. */
 function isDeepSignal(value) {
-    return !!getMeta(value);
+    return !!value?.[RAW_KEY];
 }
 /**
  * Create a deep reactive proxy for objects, arrays or Sets.
@@ -878,7 +1021,7 @@ function subscribeDeepMutations(root, cb, triggerInstantly = false) {
 }
 /** Return the root identifier symbol for a deepSignal proxy (if any). */
 function getDeepSignalRootId(value) {
-    return getMeta(value)?.root;
+    return rawToMeta.get(value?.[RAW_KEY] ?? value)?.root;
 }
 /** Retrieve the current patch version for a deepSignal root (if tracked). */
 function getDeepSignalVersion(root) {
@@ -896,7 +1039,8 @@ function shallow(obj) {
 function setSetEntrySyntheticId(obj, id) {
     if (!obj || typeof obj !== "object")
         return;
-    forcedSyntheticIds.set(getRaw(obj), String(id));
+    // @ts-ignore
+    forcedSyntheticIds.set(obj[RAW_KEY] ?? obj, String(id));
 }
 /** Convenience helper to add an entry to a proxied Set with a pre-defined synthetic ID. */
 function addWithId(set, entry, id) {

package/dist/hooks/react/useDeepSignal.d.ts

@@ -1,4 +1,4 @@
-import { DeepSignalOptions } from "../../types.js";
+import { DeepSignalOptions } from "../..";
 /**
  * Create or use an existing deepSignal object in your component.
  * Modifications to the returned deepSignal object cause an immediate rerender.
@@ -6,9 +6,9 @@ import { DeepSignalOptions } from "../../types.js";
  * is rerendered as well.
  *
  * @param object The object that should become reactive
- * @param deepSignalObjects When the object is not a deepSignal already, options passed to `deepSignal`.
- * @returns The deepSignal object of the object param.
+ * @param deepSignalOptions When the object is not a deepSignal already, options passed to `deepSignal`.
+ * @returns The deepSignal object of the object param. On every change, the returned object will change (a new no-op proxy is created) around the deepSignal object.
  */
-declare const useSignal: <T extends object>(object: T, deepSignalObjects?: DeepSignalOptions) => import("../../types.js").DeepSignal<T>;
+declare const useSignal: <T extends object>(object: T, deepSignalOptions?: DeepSignalOptions) => import("../..").DeepSignal<T>;
 export default useSignal;
 //# sourceMappingURL=useDeepSignal.d.ts.map

package/dist/hooks/react/useDeepSignal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDeepSignal.d.ts","sourceRoot":"","sources":["../../../src/hooks/react/useDeepSignal.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;;GASG;AACH,QAAA,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAC/B,QAAQ,CAAC,EACT,oBAAoB,iBAAiB,2CAqBxC,CAAC;AAEF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"useDeepSignal.d.ts","sourceRoot":"","sources":["../../../src/hooks/react/useDeepSignal.ts"],"names":[],"mappings":"AAYA,OAAO,EAAc,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEtD;;;;;;;;;GASG;AACH,QAAA,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAC/B,QAAQ,CAAC,EACT,oBAAoB,iBAAiB,kCAqCxC,CAAC;AAEF,eAAe,SAAS,CAAC"}