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

package/dist/test/lib/watch.test.js

@@ -0,0 +1,1280 @@
+"use strict";
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const __1 = require("../../");
+const watch_1 = require("../../watch");
+const effect_1 = require("../../effect");
+(0, vitest_1.describe)("watch", () => {
+    (0, vitest_1.it)("watch immediate", () => {
+        const store = (0, __1.deepSignal)({
+            userinfo: {
+                name: "tom",
+            },
+        });
+        let val;
+        (0, watch_1.watch)(store, ({ newValue }) => {
+            val = newValue.userinfo.name;
+        }, { immediate: true });
+        (0, vitest_1.expect)(val).toEqual("tom");
+    });
+    (0, vitest_1.it)("watch deep", () => {
+        const store = (0, __1.deepSignal)({
+            userinfo: {
+                name: "tom",
+            },
+        });
+        let val;
+        (0, watch_1.watch)(store, ({ newValue }) => {
+            val = newValue.userinfo.name;
+        }, { immediate: true });
+        let value2;
+        (0, watch_1.watch)(store, ({ newValue }) => {
+            value2 = newValue.userinfo.name;
+        }, { immediate: true });
+        (0, vitest_1.expect)(val).toEqual("tom");
+        store.userinfo.name = "jon";
+        // patch delivery async (microtask)
+        return Promise.resolve().then(() => {
+            (0, vitest_1.expect)(val).toEqual("jon");
+            // With refactored watch using native effect, shallow watcher now also updates root reference
+            (0, vitest_1.expect)(value2).toEqual("jon");
+        });
+    });
+    (0, vitest_1.it)("watch once", () => {
+        const store = (0, __1.deepSignal)({
+            userinfo: {
+                name: "tom",
+            },
+        });
+        let val;
+        (0, watch_1.watch)(store, ({ newValue }) => {
+            val = newValue.userinfo.name;
+        }, { immediate: true, once: true });
+        (0, vitest_1.expect)(val).toEqual("tom");
+        store.userinfo.name = "jon";
+        // once watcher shouldn't update after first run
+        (0, vitest_1.expect)(val).toEqual("tom");
+    });
+    (0, vitest_1.it)("delivers immediate snapshot", () => {
+        const state = (0, __1.deepSignal)({ user: { name: "tom" } });
+        let observed = "";
+        (0, watch_1.watch)(state, ({ newValue }) => {
+            observed = newValue.user.name;
+        }, { immediate: true });
+        (0, vitest_1.expect)(observed).toEqual("tom");
+    });
+    (0, vitest_1.it)("emits patches with version", async () => {
+        const state = (0, __1.deepSignal)({ count: 0 });
+        const versions = [];
+        (0, watch_1.watch)(state, ({ version }) => {
+            versions.push(version);
+        });
+        state.count = 1;
+        await Promise.resolve();
+        (0, vitest_1.expect)(versions.length).toBe(1);
+        (0, vitest_1.expect)(versions[0]).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("effect runs and cleans up", () => {
+        const calls = [];
+        const dispose = (0, effect_1.effect)((registerCleanup) => {
+            calls.push("run");
+            registerCleanup?.(() => calls.push("cleanup"));
+        });
+        dispose();
+        (0, vitest_1.expect)(calls).toEqual(["run", "cleanup"]);
+    });
+});
+(0, vitest_1.describe)("watch (patch mode)", () => {
+    (0, vitest_1.it)("emits set patches with correct paths and batching", async () => {
+        const state = (0, __1.deepSignal)({ a: { b: 1 }, arr: [1, { x: 2 }] });
+        const received = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+            received.push(patches);
+        });
+        state.a.b = 2;
+        state.arr[1].x = 3;
+        state.arr.push(5);
+        await Promise.resolve();
+        (0, vitest_1.expect)(received).toHaveLength(1);
+        const batch = received[0];
+        (0, vitest_1.expect)(batch).toEqual([
+            { op: "add", path: ["a", "b"], value: 2 },
+            { op: "add", path: ["arr", "1", "x"], value: 3 },
+            { op: "add", path: ["arr", "2"], value: 5 },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("emits delete patches without value", async () => {
+        const state = (0, __1.deepSignal)({
+            a: { b: 1 },
+            c: 2,
+        });
+        const out = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => out.push(patches));
+        delete state.a.b;
+        delete state.c;
+        await Promise.resolve();
+        (0, vitest_1.expect)(out).toHaveLength(1);
+        (0, vitest_1.expect)(out[0]).toEqual([
+            { op: "remove", path: ["a", "b"] },
+            { op: "remove", path: ["c"] },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("filters out patches from other roots", async () => {
+        const a = (0, __1.deepSignal)({ x: 1 });
+        const b = (0, __1.deepSignal)({ y: 2 });
+        const out = [];
+        const { stopListening: stop } = (0, watch_1.watch)(a, ({ patches }) => out.push(patches));
+        b.y = 3;
+        a.x = 2;
+        await Promise.resolve();
+        (0, vitest_1.expect)(out).toHaveLength(1);
+        (0, vitest_1.expect)(out[0]).toEqual([{ op: "add", path: ["x"], value: 2 }]);
+        stop();
+    });
+    (0, vitest_1.it)("emits patches for Set structural mutations (add/delete)", async () => {
+        const state = (0, __1.deepSignal)({ s: new Set([1, 2]) });
+        const batches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => batches.push(patches));
+        state.s.add(3);
+        state.s.delete(1);
+        await Promise.resolve();
+        const flattened = batches.flat();
+        (0, vitest_1.expect)(flattened).toEqual([
+            { op: "add", path: ["s"], type: "set", value: [3] },
+            { op: "remove", path: ["s"], type: "set", value: 1 },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("emits patches for nested objects added after initialization", async () => {
+        const state = (0, __1.deepSignal)({ root: {} });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        state.root.child = { level: { value: 1 }, l1: "val" };
+        await Promise.resolve();
+        const flattened = patches.flat();
+        (0, vitest_1.expect)(flattened).toEqual([
+            { op: "add", path: ["root", "child"], value: {} },
+            { op: "add", path: ["root", "child", "level"], value: {} },
+            {
+                op: "add",
+                path: ["root", "child", "level", "value"],
+                value: 1,
+            },
+            { op: "add", path: ["root", "child", "l1"], value: "val" },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("emits patches for Set with primitives added as one operation", async () => {
+        const state = (0, __1.deepSignal)({ container: {} }, {
+            syntheticIdPropertyName: "id",
+        });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(...batch));
+        state.container.items = new Set(["item1"]);
+        state.container.items.add("item2");
+        await Promise.resolve();
+        (0, vitest_1.expect)(patches).toHaveLength(3);
+        (0, vitest_1.expect)(patches[0]).toMatchObject({
+            op: "add",
+            path: ["container", "items"],
+            type: "set",
+        });
+        (0, vitest_1.expect)(patches[1]).toMatchObject({
+            op: "add",
+            path: ["container", "items"],
+            type: "set",
+            value: ["item1"],
+        });
+        (0, vitest_1.expect)(patches[2]).toMatchObject({
+            op: "add",
+            path: ["container", "items"],
+            type: "set",
+            value: ["item2"],
+        });
+        stop();
+    });
+    (0, vitest_1.it)("emits patches for deeply nested arrays and objects", async () => {
+        const state = (0, __1.deepSignal)({ data: null });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        state.data = {
+            users: [
+                {
+                    id: 1,
+                    profile: { name: "Alice", settings: { theme: "dark" } },
+                },
+                {
+                    id: 2,
+                    profile: { name: "Bob", settings: { theme: "light" } },
+                },
+            ],
+            meta: { count: 2, active: true },
+        };
+        await Promise.resolve();
+        const flattened = patches.flat();
+        (0, vitest_1.expect)(flattened).toEqual([
+            { op: "add", path: ["data"], value: {}, type: undefined },
+            { op: "add", path: ["data", "users"], value: [], type: undefined },
+            {
+                op: "add",
+                path: ["data", "users", 0],
+                value: {},
+                type: undefined,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 0, "id"],
+                value: 1,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 0, "profile"],
+                value: {},
+                type: undefined,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 0, "profile", "name"],
+                value: "Alice",
+            },
+            {
+                op: "add",
+                path: ["data", "users", 0, "profile", "settings"],
+                value: {},
+                type: undefined,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 0, "profile", "settings", "theme"],
+                value: "dark",
+            },
+            {
+                op: "add",
+                path: ["data", "users", 1],
+                value: {},
+                type: undefined,
+            },
+            { op: "add", path: ["data", "users", 1, "id"], value: 2 },
+            {
+                op: "add",
+                path: ["data", "users", 1, "profile"],
+                value: {},
+                type: undefined,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 1, "profile", "name"],
+                value: "Bob",
+            },
+            {
+                op: "add",
+                path: ["data", "users", 1, "profile", "settings"],
+                value: {},
+                type: undefined,
+            },
+            {
+                op: "add",
+                path: ["data", "users", 1, "profile", "settings", "theme"],
+                value: "light",
+            },
+            { op: "add", path: ["data", "meta"], value: {}, type: undefined },
+            { op: "add", path: ["data", "meta", "count"], value: 2 },
+            { op: "add", path: ["data", "meta", "active"], value: true },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("emits patches for Set with nested objects added as one operation", async () => {
+        const state = (0, __1.deepSignal)({ container: {} }, {
+            syntheticIdPropertyName: "id",
+            propGenerator: ({ object }) => ({ syntheticId: object.id }),
+        });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        state.container.items = new Set([
+            { id: "a", data: { nested: { value: 1 } } },
+            { id: "b", data: { nested: { value: 2 } } },
+        ]);
+        await Promise.resolve();
+        const flattened = patches.flat();
+        (0, vitest_1.expect)(flattened).toEqual([
+            { op: "add", path: ["container", "items"], type: "set", value: [] },
+            { op: "add", path: ["container", "items", "a"], value: {} },
+            { op: "add", path: ["container", "items", "a", "id"], value: "a" },
+            {
+                op: "add",
+                path: ["container", "items", "a", "data"],
+                value: {},
+            },
+            {
+                op: "add",
+                path: ["container", "items", "a", "data", "nested"],
+                value: {},
+            },
+            {
+                op: "add",
+                path: ["container", "items", "a", "data", "nested", "value"],
+                value: 1,
+            },
+            { op: "add", path: ["container", "items", "b"], value: {} },
+            { op: "add", path: ["container", "items", "b", "id"], value: "b" },
+            {
+                op: "add",
+                path: ["container", "items", "b", "data"],
+                value: {},
+            },
+            {
+                op: "add",
+                path: ["container", "items", "b", "data", "nested"],
+                value: {},
+            },
+            {
+                op: "add",
+                path: ["container", "items", "b", "data", "nested", "value"],
+                value: 2,
+            },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("emits structural patches for sets of sets", async () => {
+        const innerA = new Set([{ id: "node1", x: 1 }]);
+        const s = new Set([innerA]);
+        const state = (0, __1.deepSignal)({ graph: s });
+        const batches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => batches.push(patches));
+        const innerB = new Set([{ id: "node2", x: 5 }]);
+        state.graph.add(innerB);
+        [...innerA][0].x = 2;
+        await Promise.resolve();
+        const pathStrings = batches.flat().map((p) => p.path.join("."));
+        (0, vitest_1.expect)(pathStrings.some((p) => p.startsWith("graph."))).toBe(true);
+        stop();
+    });
+    (0, vitest_1.it)("tracks deep nested object mutation inside a Set entry after iteration", async () => {
+        const rawEntry = { id: "n1", data: { val: 1 } };
+        const st = (0, __1.deepSignal)({ bag: new Set([rawEntry]) }, {
+            syntheticIdPropertyName: "id",
+            propGenerator: ({ object }) => ({ syntheticId: object.id }),
+        });
+        const collected = [];
+        const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => collected.push(patches));
+        let proxied;
+        for (const e of st.bag.values()) {
+            proxied = e;
+            e.data.val;
+        }
+        proxied.data.val = 2;
+        await Promise.resolve();
+        const flat = collected.flat().map((p) => p.path.join("."));
+        (0, vitest_1.expect)(flat.some((p) => p.endsWith("n1.data.val"))).toBe(true);
+        stop();
+    });
+    (0, vitest_1.it)("allows custom synthetic id for Set entry", async () => {
+        const node = { name: "x" };
+        const state = (0, __1.deepSignal)({ s: new Set() });
+        const collected2 = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => collected2.push(patches));
+        (0, __1.addWithId)(state.s, node, "custom123");
+        await Promise.resolve();
+        const flat = collected2.flat().map((p) => p.path.join("."));
+        (0, vitest_1.expect)(flat.some((p) => p === "s.custom123")).toBe(true);
+        stop();
+    });
+    (0, vitest_1.it)("should apply extraProps returned from propGenerator when adding objects to Set", async () => {
+        const options = {
+            propGenerator: ({ path, object }) => {
+                // Generate @graph and @id if not present or empty
+                const graphIri = !object["@graph"] || object["@graph"] === ""
+                    ? "did:ng:test-graph"
+                    : object["@graph"];
+                const subjectIri = !object["@id"] || object["@id"] === ""
+                    ? `did:ng:test-subject-${Math.random()}`
+                    : object["@id"];
+                return {
+                    extraProps: { "@id": subjectIri, "@graph": graphIri },
+                    syntheticId: graphIri + "|" + subjectIri,
+                };
+            },
+        };
+        const state = (0, __1.deepSignal)(new Set(), options);
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        // Add object with empty @graph and @id (should be replaced)
+        const newObj = { "@graph": "", "@id": "", name: "Test Object" };
+        state.add(newObj);
+        await Promise.resolve();
+        // Check that extraProps were applied to the object
+        (0, vitest_1.expect)(newObj["@id"]).toBeDefined();
+        (0, vitest_1.expect)(newObj["@graph"]).toBeDefined();
+        (0, vitest_1.expect)(newObj["@graph"]).toBe("did:ng:test-graph");
+        // Check that patches were emitted with the generated values
+        const allPatches = patches.flat();
+        const idPatch = allPatches.find((p) => p.path.length === 2 && p.path[1] === "@id");
+        const graphPatch = allPatches.find((p) => p.path.length === 2 && p.path[1] === "@graph");
+        (0, vitest_1.expect)(idPatch).toBeDefined();
+        (0, vitest_1.expect)(idPatch?.op).toBe("add");
+        (0, vitest_1.expect)(idPatch?.value).toBeDefined();
+        (0, vitest_1.expect)(idPatch?.value?.startsWith("did:ng:test-subject")).toBeTruthy();
+        (0, vitest_1.expect)(graphPatch).toBeDefined();
+        (0, vitest_1.expect)(graphPatch?.op).toBe("add");
+        (0, vitest_1.expect)(graphPatch?.value).toBe("did:ng:test-graph");
+        stop();
+    });
+    (0, vitest_1.describe)("Set", () => {
+        (0, vitest_1.it)("emits patches for primitive adds", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.s.add(true);
+            st.s.add(2);
+            st.s.add("3");
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(1);
+            const patches = batches[0];
+            (0, vitest_1.expect)(patches.length).toBe(3);
+            // All patches should have the same path (the Set itself)
+            patches.forEach((p) => {
+                (0, vitest_1.expect)(p.path.join(".")).toBe("s");
+                (0, vitest_1.expect)(p.op).toBe("add");
+                (0, vitest_1.expect)(p.type).toBe("set");
+            });
+            // Check that values are in the value field, not in path
+            const values = patches.map((p) => p.value[0]);
+            (0, vitest_1.expect)(values).toContain(true);
+            (0, vitest_1.expect)(values).toContain(2);
+            (0, vitest_1.expect)(values).toContain("3");
+            stop();
+        });
+        (0, vitest_1.it)("emits patches for primitive deletes", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set([true, 2, "3"]) });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.s.delete(true);
+            st.s.delete(2);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(1);
+            const patches = batches[0];
+            (0, vitest_1.expect)(patches.length).toBe(2);
+            // All patches should have the same path (the Set itself)
+            patches.forEach((p) => {
+                (0, vitest_1.expect)(p.path.join(".")).toBe("s");
+                (0, vitest_1.expect)(p.op).toBe("remove");
+                (0, vitest_1.expect)(p.type).toBe("set");
+            });
+            // Check that values are in the value field
+            const values = patches.map((p) => p.value);
+            (0, vitest_1.expect)(values).toContain(true);
+            (0, vitest_1.expect)(values).toContain(2);
+            stop();
+        });
+        (0, vitest_1.it)("does not emit patches for non-existent primitives", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set([1, 2]) });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.s.delete("nonexistent");
+            st.s.delete(999);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(0);
+            stop();
+        });
+        (0, vitest_1.it)("does not emit patches for already added primitive", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set([1, "test", true]) });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.s.add(1);
+            st.s.add("test");
+            st.s.add(true);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(0);
+            stop();
+        });
+        (0, vitest_1.it)("emits single structural patch on Set.clear()", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            (0, __1.addWithId)(st.s, { id: "a", x: 1 }, "a");
+            (0, __1.addWithId)(st.s, { id: "b", x: 2 }, "b");
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.s.clear();
+            await Promise.resolve();
+            // clear() emits a single structural patch for the Set itself (op: "add", value: [])
+            const structuralPatches = batches
+                .flat()
+                .filter((p) => p.path.length === 1 && p.path[0] === "s");
+            (0, vitest_1.expect)(structuralPatches.length).toBe(1);
+            (0, vitest_1.expect)(structuralPatches[0].op).toBe("add");
+            (0, vitest_1.expect)(structuralPatches[0].value).toEqual([]);
+            stop();
+        });
+        (0, vitest_1.it)("emits delete patch for object entry", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() }, {
+                syntheticIdPropertyName: "id",
+                propGenerator: ({ object }) => ({ syntheticId: object.id }),
+            });
+            const obj = { id: "n1", x: 1 };
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            st.s.add(obj);
+            st.s.delete(obj);
+            await Promise.resolve();
+            const all = patches
+                .flat()
+                .filter((p) => p.op === "remove")
+                .map((p) => p.path.join("."));
+            (0, vitest_1.expect)(all).toContain("s.n1");
+            stop();
+        });
+        (0, vitest_1.it)("does not emit patch for duplicate add", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set([1]) });
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            st.s.add(1);
+            await Promise.resolve();
+            (0, vitest_1.expect)(patches.length).toBe(0);
+            stop();
+        });
+        (0, vitest_1.it)("does not emit patch deleting non-existent entry", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set([1]) });
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            st.s.delete(2);
+            await Promise.resolve();
+            (0, vitest_1.expect)(patches.length).toBe(0);
+            stop();
+        });
+        (0, vitest_1.it)("addWithId primitive returns primitive and emits patch with primitive key", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            const ret = (0, __1.addWithId)(st.s, 5, "ignored");
+            (0, vitest_1.expect)(ret).toBe(5);
+            await Promise.resolve();
+            // For primitives, path should be just "s" and value should be in the value field
+            const paths = patches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(paths).toContain("s");
+            const values = patches.flat().map((p) => p.value?.[0]);
+            (0, vitest_1.expect)(values).toContain(5);
+            stop();
+        });
+        (0, vitest_1.it)("setSetEntrySyntheticId applies custom id without helper", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            const obj = { name: "x" };
+            (0, __1.setSetEntrySyntheticId)(obj, "customX");
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            st.s.add(obj);
+            await Promise.resolve();
+            const paths = patches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(paths).toContain("s.customX");
+            stop();
+        });
+        (0, vitest_1.it)("values/entries/forEach proxy nested mutation", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            const entry = (0, __1.addWithId)(st.s, { id: "e1", inner: { v: 1 } }, "e1");
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            for (const e of st.s.values()) {
+                e.inner.v;
+            }
+            entry.inner.v = 2;
+            await Promise.resolve();
+            const vPaths = batches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(vPaths.some((p) => p.endsWith("e1.inner.v"))).toBe(true);
+            stop();
+        });
+        (0, vitest_1.it)("raw reference mutation produces no deep patch while proxied does", async () => {
+            const raw = { id: "id1", data: { x: 1 } };
+            const st = (0, __1.deepSignal)({ s: new Set([raw]) }, {
+                syntheticIdPropertyName: "id",
+                propGenerator: ({ object }) => ({ syntheticId: object.id }),
+            });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            raw.data.x = 2;
+            await Promise.resolve();
+            const afterRaw = batches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(afterRaw.some((p) => p.endsWith("id1.data.x"))).toBe(false);
+            let proxied;
+            for (const e of st.s.values())
+                proxied = e;
+            proxied.data.x = 3;
+            await Promise.resolve();
+            const afterProxied = batches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(afterProxied.some((p) => p.endsWith("id1.data.x"))).toBe(true);
+            stop();
+        });
+        (0, vitest_1.it)("synthetic id collision assigns unique blank node id", async () => {
+            const st = (0, __1.deepSignal)({ s: new Set() });
+            const a1 = { id: "dup", v: 1 };
+            const a2 = { id: "dup", v: 2 };
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            st.s.add(a1);
+            st.s.add(a2);
+            await Promise.resolve();
+            // Filter for Set structural patches only (path length 2: ['s', syntheticId])
+            const setAddPatches = patches
+                .flat()
+                .filter((p) => p.op === "add" &&
+                p.path.length === 2 &&
+                p.path[0] === "s");
+            const keys = setAddPatches.map((p) => p.path.slice(-1)[0]);
+            // Both objects should have unique synthetic IDs despite id collision
+            (0, vitest_1.expect)(new Set(keys).size).toBe(2);
+            stop();
+        });
+        (0, vitest_1.it)("allows Array.from() and spread on Set without brand errors and tracks nested mutation", async () => {
+            const st = (0, __1.deepSignal)({
+                s: new Set([{ id: "eIter", inner: { v: 1 } }]),
+            }, {
+                syntheticIdPropertyName: "id",
+                propGenerator: ({ object }) => ({ syntheticId: object.id }),
+            });
+            // Regression: previously 'values method called on incompatible Proxy' was thrown here.
+            const arr = Array.from(st.s);
+            (0, vitest_1.expect)(arr.length).toBe(1);
+            (0, vitest_1.expect)(arr[0].inner.v).toBe(1);
+            const spread = [...st.s];
+            (0, vitest_1.expect)(spread[0].inner.v).toBe(1);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            spread[0].inner.v = 2; // mutate nested field of iterated (proxied) entry
+            await Promise.resolve();
+            const flat = batches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(flat.some((p) => p.endsWith("eIter.inner.v"))).toBe(true);
+            stop();
+        });
+        (0, vitest_1.it)("generates correct patches when root is a Set (primitive entries)", async () => {
+            const rootSet = (0, __1.deepSignal)(new Set());
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(rootSet, ({ patches }) => batches.push(patches));
+            rootSet.add(1);
+            rootSet.add("test");
+            rootSet.add(true);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(1);
+            const patches = batches[0];
+            (0, vitest_1.expect)(patches.length).toBe(3);
+            // When root is a Set, path should be empty array for primitive adds
+            patches.forEach((p) => {
+                (0, vitest_1.expect)(p.path).toEqual([]);
+                (0, vitest_1.expect)(p.op).toBe("add");
+                (0, vitest_1.expect)(p.type).toBe("set");
+            });
+            const values = patches.map((p) => p.value[0]);
+            (0, vitest_1.expect)(values).toContain(1);
+            (0, vitest_1.expect)(values).toContain("test");
+            (0, vitest_1.expect)(values).toContain(true);
+            stop();
+        });
+        (0, vitest_1.it)("generates correct patches when root is a Set (object entries)", async () => {
+            const rootSet = (0, __1.deepSignal)(new Set(), {
+                propGenerator: ({ object }) => ({
+                    syntheticId: object["@id"] || `fallback-${Math.random()}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(rootSet, ({ patches }) => batches.push(patches));
+            const obj1 = { "@id": "obj1", value: 1 };
+            const obj2 = { "@id": "obj2", value: 2 };
+            rootSet.add(obj1);
+            rootSet.add(obj2);
+            await Promise.resolve();
+            const flat = batches.flat().map((p) => p.path.join("."));
+            // When root is a Set, first element of path should be synthetic id
+            (0, vitest_1.expect)(flat).toContain("obj1");
+            (0, vitest_1.expect)(flat).toContain("obj1.@id");
+            (0, vitest_1.expect)(flat).toContain("obj1.value");
+            (0, vitest_1.expect)(flat).toContain("obj2");
+            (0, vitest_1.expect)(flat).toContain("obj2.@id");
+            (0, vitest_1.expect)(flat).toContain("obj2.value");
+            stop();
+        });
+        (0, vitest_1.it)("tracks nested mutations when root is a Set", async () => {
+            const rootSet = (0, __1.deepSignal)(new Set(), {
+                syntheticIdPropertyName: "id",
+                propGenerator: ({ object }) => ({ syntheticId: object.id }),
+            });
+            const obj = { id: "nested", data: { x: 1 } };
+            rootSet.add(obj);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(rootSet, ({ patches }) => batches.push(patches));
+            // Get the proxied entry
+            let proxied;
+            for (const e of rootSet.values()) {
+                proxied = e;
+            }
+            proxied.data.x = 2;
+            await Promise.resolve();
+            const flat = batches.flat().map((p) => p.path.join("."));
+            (0, vitest_1.expect)(flat.some((p) => p === "nested.data.x")).toBe(true);
+            stop();
+        });
+    });
+    (0, vitest_1.describe)("Arrays & mixed batch", () => {
+        (0, vitest_1.it)("emits patches for splice/unshift/shift in single batch", async () => {
+            const st = (0, __1.deepSignal)({ arr: [1, 2, 3] });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => {
+                batches.push(patches);
+            });
+            st.arr.splice(1, 1, 99, 100);
+            st.arr.unshift(0);
+            st.arr.shift();
+            await Promise.resolve();
+            (0, vitest_1.expect)(st.arr).toEqual([1, 99, 100, 3]);
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                { path: ["arr", "1"], op: "remove" },
+                { path: ["arr", "1"], op: "add", value: 100 },
+                { path: ["arr", "1"], op: "add", value: 99 },
+                { path: ["arr", "0"], op: "add", value: 0 },
+                { path: ["arr", "0"], op: "remove" },
+            ]);
+            stop();
+        });
+        (0, vitest_1.it)("emits patches adding new array", async () => {
+            const obj = (0, __1.deepSignal)({});
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(obj, ({ patches }) => {
+                batches.push(patches);
+            });
+            obj.arr = [1, 2, 3];
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                { path: ["arr"], op: "add", value: [] },
+                { path: ["arr", 0], op: "add", value: 1 },
+                { path: ["arr", 1], op: "add", value: 2 },
+                { path: ["arr", 2], op: "add", value: 3 },
+            ]);
+            stop();
+        });
+        (0, vitest_1.it)("emits remove patches when array length shrinks", async () => {
+            const st = (0, __1.deepSignal)([1, 0, 3, -1]);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => {
+                batches.push(patches);
+            });
+            st.length = 2;
+            await Promise.resolve();
+            (0, vitest_1.expect)(st).toEqual([1, 0]);
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                { path: ["3"], op: "remove" },
+                { path: ["2"], op: "remove" },
+            ]);
+            stop();
+        });
+        (0, vitest_1.it)("mixed object/array/Set mutations batch together", async () => {
+            const st = (0, __1.deepSignal)({ o: { a: 1 }, arr: [1], s: new Set() });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            st.o.a = 2;
+            st.arr.push(2);
+            (0, __1.addWithId)(st.s, { id: "z", v: 1 }, "z");
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches.length).toBe(1);
+            const paths = batches[0].map((p) => p.path.join("."));
+            (0, vitest_1.expect)(paths).toContain("o.a");
+            (0, vitest_1.expect)(paths).toContain("arr.1");
+            (0, vitest_1.expect)(paths.some((p) => p.startsWith("s."))).toBe(true);
+            stop();
+        });
+        (0, vitest_1.it)("mutating existing Set property emits correct patches", async () => {
+            const obj2 = {
+                "@id": "urn:test:obj2|did:ng:o:xypN3xdPs4ozIXaCFOQ5tDmq86q0szbqtCQmcqTcMTcA:v:QvO7rDIp1MCUs3Xec-yQBl0kHjMmLzoUOU4m6qy6b4EA",
+                setProperty: new Set([1, 2, 3]),
+            };
+            const st = (0, __1.deepSignal)({ items: new Set([obj2]) }, {
+                syntheticIdPropertyName: "@id",
+                propGenerator: ({ object }) => ({
+                    syntheticId: object["@id"],
+                }),
+            });
+            // Get the proxied object from the set
+            let proxiedObj;
+            for (const item of st.items) {
+                proxiedObj = item;
+            }
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            // Modify the Set property: remove one value and add another
+            proxiedObj.setProperty.delete(3);
+            proxiedObj.setProperty.add(4);
+            proxiedObj.setProperty.add(5);
+            await Promise.resolve();
+            const patches = batches.flat();
+            // Should NOT have an object patch for the Set itself when modifying existing Set
+            const objectPatches = patches.filter((p) => p.type === "object");
+            (0, vitest_1.expect)(objectPatches.length).toBe(0);
+            // Should have remove patch for deleted value
+            const removePatches = patches.filter((p) => p.op === "remove");
+            (0, vitest_1.expect)(removePatches.length).toBe(1);
+            (0, vitest_1.expect)(removePatches[0].value).toBe(3);
+            // Should have add patches for new values (primitives in Set)
+            const addPatches = patches.filter((p) => p.op === "add");
+            (0, vitest_1.expect)(addPatches.length).toBe(2);
+            const addedValues = addPatches.map((p) => p.value[0]);
+            (0, vitest_1.expect)(addedValues).toContain(4);
+            (0, vitest_1.expect)(addedValues).toContain(5);
+            stop();
+        });
+        (0, vitest_1.it)("reassigning Set property should not emit deep patches for all elements", async () => {
+            const obj2 = {
+                "@id": "urn:test:obj2|did:ng:o:xypN3xdPs4ozIXaCFOQ5tDmq86q0szbqtCQmcqTcMTcA:v:QvO7rDIp1MCUs3Xec-yQBl0kHjMmLzoUOU4m6qy6b4EA",
+                setProperty: new Set([1, 2, 3]),
+            };
+            const st = (0, __1.deepSignal)({ items: new Set([obj2]) }, {
+                syntheticIdPropertyName: "@id",
+                propGenerator: ({ object }) => ({
+                    syntheticId: object["@id"],
+                }),
+            });
+            // Get the proxied object from the set
+            let proxiedObj;
+            for (const item of st.items) {
+                proxiedObj = item;
+            }
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            // Reassign the Set property to a new Set with different values
+            proxiedObj.setProperty = new Set([4, 5]);
+            await Promise.resolve();
+            const patches = batches.flat();
+            // When reassigning a complex object property (Set/Array/Object) to a new value,
+            // we should NOT emit:
+            // 1. An "object" type patch for the container
+            // 2. Individual "add" patches for each element
+            //
+            // This was the bug reported: replacing a Set emitted patches like:
+            // [{ path: [..., "setProperty"], op: "add", value: {} },
+            //  { path: [..., "setProperty", 4], op: "add", value: 4 },
+            //  { path: [..., "setProperty", 5], op: "add", value: 5 }]
+            //
+            // The correct behavior: no deep patches for the reassignment.
+            // Subsequent mutations (add/delete) on the new Set will emit proper patches.
+            const objectPatches = patches.filter((p) => p.type === "object");
+            (0, vitest_1.expect)(objectPatches.length).toBe(0);
+            // No individual element patches should be emitted for the initial elements
+            const elementPatches = patches.filter((p) => (p.path.length > 2 && p.path[p.path.length - 1] === 4) ||
+                p.path[p.path.length - 1] === 5);
+            (0, vitest_1.expect)(elementPatches.length).toBe(0);
+            // Verify that subsequent operations on the new Set DO emit patches
+            proxiedObj.setProperty.add(6);
+            await Promise.resolve();
+            const laterPatches = batches.flat();
+            const patch6 = laterPatches.find((p) => p.value?.[0] === 6 || p.value === 6);
+            (0, vitest_1.expect)(patch6).toBeDefined();
+            stop();
+        });
+        (0, vitest_1.it)("calls propGenerator for objects with nested Set structures (Set inside Set)", async () => {
+            const propGeneratorCalls = [];
+            const st = (0, __1.deepSignal)({ items: new Set() }, {
+                syntheticIdPropertyName: "@id",
+                propGenerator: ({ object, path, inSet }) => {
+                    propGeneratorCalls.push({ object, path, inSet });
+                    return {
+                        syntheticId: object["@id"] || `fallback-${Math.random()}`,
+                    };
+                },
+            });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            // Create nested objects that will be in the inner Set
+            const innerObj1 = { "@id": "inner1", value: "nested1" };
+            const innerObj2 = { "@id": "inner2", value: "nested2" };
+            const nestedSet = new Set([innerObj1, innerObj2]);
+            // Create outer object with nested Set
+            const outerObj = {
+                "@id": "outer-with-nested-set",
+                nestedSet: nestedSet,
+            };
+            st.items.add(outerObj);
+            await Promise.resolve();
+            // Verify propGenerator was called for the outer object
+            const outerCall = propGeneratorCalls.find((call) => call.object === outerObj);
+            (0, vitest_1.expect)(outerCall).toBeDefined();
+            (0, vitest_1.expect)(outerCall.object["@id"]).toBe("outer-with-nested-set");
+            // Verify propGenerator was called for inner objects
+            const inner1Call = propGeneratorCalls.find((call) => call.object === innerObj1);
+            (0, vitest_1.expect)(inner1Call).toBeDefined();
+            (0, vitest_1.expect)(inner1Call.object["@id"]).toBe("inner1");
+            const inner2Call = propGeneratorCalls.find((call) => call.object === innerObj2);
+            (0, vitest_1.expect)(inner2Call).toBeDefined();
+            (0, vitest_1.expect)(inner2Call.object["@id"]).toBe("inner2");
+            // Verify patches were emitted correctly
+            const patches = batches.flat();
+            const flat = patches.map((p) => p.path.join("."));
+            // Should have patch for the outer object
+            (0, vitest_1.expect)(flat.some((p) => p.startsWith("items.outer-with-nested-set"))).toBe(true);
+            // Should have patches for the nested Set and its objects
+            (0, vitest_1.expect)(flat.some((p) => p.includes("nestedSet"))).toBe(true);
+            (0, vitest_1.expect)(flat.some((p) => p.includes("inner1"))).toBe(true);
+            (0, vitest_1.expect)(flat.some((p) => p.includes("inner2"))).toBe(true);
+            stop();
+        });
+        (0, vitest_1.it)("calls propGenerator for deeply nested Sets (multiple levels)", async () => {
+            const propGeneratorCalls = [];
+            const st = (0, __1.deepSignal)(new Set(), {
+                syntheticIdPropertyName: "@id",
+                propGenerator: ({ object, path, inSet }) => {
+                    propGeneratorCalls.push({ object, path, inSet });
+                    return {
+                        syntheticId: object["@id"] + "-withCustomString",
+                    };
+                },
+            });
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            // Create structure matching real use case:
+            // Root Set contains objects with did:ng:o: IDs
+            // Those objects have properties that are Sets of more objects
+            const innerObj = { "@id": "innerId", prop2: "initial value" };
+            const anotherObjectSet = new Set([innerObj]);
+            const outerObj = {
+                "@id": "outerId",
+                anotherObject: anotherObjectSet,
+            };
+            st.add(outerObj);
+            await Promise.resolve();
+            // Verify propGenerator was called for all objects
+            (0, vitest_1.expect)(propGeneratorCalls.some((call) => call.object === outerObj)).toBe(true);
+            (0, vitest_1.expect)(propGeneratorCalls.some((call) => call.object === innerObj)).toBe(true);
+            // Clear batches for mutation test
+            batches.length = 0;
+            // Get proxied objects through iteration
+            let proxiedOuter;
+            for (const obj of st.values()) {
+                proxiedOuter = obj;
+            }
+            let proxiedInner;
+            for (const obj of proxiedOuter.anotherObject.values()) {
+                proxiedInner = obj;
+            }
+            // Modify the deeply nested property
+            proxiedInner.prop2 = "modified value";
+            await Promise.resolve();
+            const mutationPatches = batches.flat();
+            const mutationPaths = mutationPatches.map((p) => p.path.join("."));
+            // The path should match: ["rootId", "anotherObject", "innerId", "prop2"]
+            const prop2Path = mutationPaths.find((p) => p.endsWith("prop2"));
+            (0, vitest_1.expect)(prop2Path).toBeDefined();
+            // Verify the path segments
+            const pathSegments = prop2Path?.split(".");
+            (0, vitest_1.expect)(pathSegments?.length).toBe(4);
+            (0, vitest_1.expect)(pathSegments?.[0]).toBe("outerId-withCustomString");
+            (0, vitest_1.expect)(pathSegments?.[1]).toBe("anotherObject");
+            (0, vitest_1.expect)(pathSegments?.[2]).toBe("innerId-withCustomString");
+            (0, vitest_1.expect)(pathSegments?.[3]).toBe("prop2");
+            stop();
+        });
+        (0, vitest_1.it)("Does not mutate calling .sort() and .reverse()", async () => {
+            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            signalObject.sort();
+            signalObject.reverse();
+            (0, vitest_1.expect)(signalObject).toEqual([1, 3, 2]);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches).toHaveLength(0);
+            stop();
+        });
+        (0, vitest_1.it)("Emits patches on .shift()", async () => {
+            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            signalObject.shift();
+            (0, vitest_1.expect)(signalObject).toEqual([3, 2]);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                {
+                    op: "remove",
+                    path: ["0"],
+                },
+            ]);
+        });
+        (0, vitest_1.it)("Emits patches on .splice()", async () => {
+            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            signalObject.splice(1, 1, 10);
+            await Promise.resolve();
+            (0, vitest_1.expect)(signalObject).toEqual([1, 10, 2]);
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                {
+                    op: "remove",
+                    path: ["1"],
+                },
+                {
+                    op: "add",
+                    path: ["1"],
+                    value: 10,
+                },
+            ]);
+        });
+        (0, vitest_1.it)("Does not mutate calling .unshift()", async () => {
+            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+            const batches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            signalObject.unshift(-1, 0);
+            (0, vitest_1.expect)(signalObject).toEqual([-1, 0, 1, 3, 2]);
+            await Promise.resolve();
+            (0, vitest_1.expect)(batches[0]).toEqual([
+                {
+                    op: "add",
+                    path: ["0"],
+                    value: 0,
+                },
+                {
+                    op: "add",
+                    path: ["0"],
+                    value: -1,
+                },
+            ]);
+        });
+    });
+    (0, vitest_1.describe)("delete patches", () => {
+        (0, vitest_1.it)("emits delete patch when removing objects with @id from Sets", async () => {
+            const options = {
+                propGenerator: ({ object }) => ({
+                    syntheticId: object["@id"] || `fallback-${Math.random()}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, __1.deepSignal)({ s: new Set() }, options);
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            // Add objects with @id
+            const obj1 = { "@id": "obj-1", value: 1 };
+            const obj2 = { "@id": "obj-2", value: 2 };
+            const obj3 = { "@id": "obj-3", value: 3 };
+            state.s.add(obj1);
+            state.s.add(obj2);
+            state.s.add(obj3);
+            await Promise.resolve();
+            // Get the proxied objects from the Set
+            const proxiedObjs = Array.from(state.s);
+            const proxiedObj2 = proxiedObjs.find((o) => o["@id"] === "obj-2");
+            // Clear patches from additions
+            patches.length = 0;
+            // Delete one object using the proxied object
+            state.s.delete(proxiedObj2);
+            await Promise.resolve();
+            // Check that delete patch was emitted with correct path
+            const deletePaths = patches
+                .flat()
+                .filter((p) => p.op === "remove")
+                .map((p) => p.path.join("."));
+            (0, vitest_1.expect)(deletePaths).toContain("s.obj-2");
+            (0, vitest_1.expect)(deletePaths).not.toContain("s.obj-1");
+            (0, vitest_1.expect)(deletePaths).not.toContain("s.obj-3");
+            stop();
+        });
+        (0, vitest_1.it)("emits delete patches when removing objects without explicit @id from Sets", async () => {
+            const options = {
+                propGenerator: () => ({
+                    syntheticId: `gen-${Math.random().toString(36).substr(2, 9)}`,
+                }),
+                syntheticIdPropertyName: "@id",
+            };
+            const state = (0, __1.deepSignal)({ s: new Set() }, options);
+            // Add objects without @id - they should get generated IDs
+            const obj1 = { value: 1 };
+            const obj2 = { value: 2 };
+            state.s.add(obj1);
+            state.s.add(obj2);
+            // Get the proxied objects and their generated IDs
+            const proxiedObjs = Array.from(state.s);
+            const proxiedObj1 = proxiedObjs[0];
+            const proxiedObj2 = proxiedObjs[1];
+            const id1 = proxiedObj1["@id"];
+            const id2 = proxiedObj2["@id"];
+            (0, vitest_1.expect)(id1).toBeDefined();
+            (0, vitest_1.expect)(id2).toBeDefined();
+            const patches = [];
+            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            // Delete one object using the proxied object
+            state.s.delete(proxiedObj1);
+            await Promise.resolve();
+            // Check that delete patch was emitted with the generated ID
+            const deletePaths = patches
+                .flat()
+                .filter((p) => p.op === "remove")
+                .map((p) => p.path.join("."));
+            (0, vitest_1.expect)(deletePaths).toContain(`s.${id1}`);
+            (0, vitest_1.expect)(deletePaths).not.toContain(`s.${id2}`);
+            stop();
+        });
+    });
+});
+(0, vitest_1.describe)("watch (triggerInstantly / JIT listeners)", () => {
+    (0, vitest_1.it)("triggers callback synchronously when triggerInstantly is true", () => {
+        const state = (0, __1.deepSignal)({ count: 0 });
+        const callTimes = [];
+        let syncMarker = 0;
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+            callTimes.push(syncMarker);
+        }, { triggerInstantly: true });
+        syncMarker = 1;
+        state.count = 1;
+        syncMarker = 2;
+        // Callback should have been called synchronously (at syncMarker = 1)
+        (0, vitest_1.expect)(callTimes).toEqual([1]);
+        stop();
+    });
+    (0, vitest_1.it)("triggers callback asynchronously when triggerInstantly is false", async () => {
+        const state = (0, __1.deepSignal)({ count: 0 });
+        const callTimes = [];
+        let syncMarker = 0;
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+            callTimes.push(syncMarker);
+        });
+        syncMarker = 1;
+        state.count = 1;
+        syncMarker = 2;
+        // Callback should NOT have been called yet (batched in microtask)
+        (0, vitest_1.expect)(callTimes).toEqual([]);
+        await Promise.resolve();
+        // Now callback should have been called (at syncMarker = 2)
+        (0, vitest_1.expect)(callTimes).toEqual([2]);
+        stop();
+    });
+    (0, vitest_1.it)("JIT listener receives patches without version", () => {
+        const state = (0, __1.deepSignal)({ value: "initial" });
+        let receivedVersion = 999; // sentinel value
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches, version }) => {
+            receivedVersion = version;
+        }, { triggerInstantly: true });
+        state.value = "changed";
+        // JIT listeners should not receive a version (it's undefined)
+        (0, vitest_1.expect)(receivedVersion).toBeUndefined();
+        stop();
+    });
+    (0, vitest_1.it)("batched listener receives patches with version", async () => {
+        const state = (0, __1.deepSignal)({ value: "initial" });
+        let receivedVersion;
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches, version }) => {
+            receivedVersion = version;
+        });
+        state.value = "changed";
+        await Promise.resolve();
+        // Batched listeners should receive a version number
+        (0, vitest_1.expect)(receivedVersion).toBeDefined();
+        (0, vitest_1.expect)(typeof receivedVersion).toBe("number");
+        (0, vitest_1.expect)(receivedVersion).toBeGreaterThan(0);
+        stop();
+    });
+    (0, vitest_1.it)("JIT listener is called for each mutation, not batched", () => {
+        const state = (0, __1.deepSignal)({ a: 1, b: 2 });
+        const patchCalls = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+            patchCalls.push([...patches]);
+        }, { triggerInstantly: true });
+        state.a = 10;
+        state.b = 20;
+        // Should be called twice (once per mutation), not once with batched patches
+        (0, vitest_1.expect)(patchCalls).toHaveLength(2);
+        (0, vitest_1.expect)(patchCalls[0]).toEqual([{ op: "add", path: ["a"], value: 10 }]);
+        (0, vitest_1.expect)(patchCalls[1]).toEqual([{ op: "add", path: ["b"], value: 20 }]);
+        stop();
+    });
+    (0, vitest_1.it)("batched listener receives all mutations in one batch", async () => {
+        const state = (0, __1.deepSignal)({ a: 1, b: 2 });
+        const patchCalls = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+            patchCalls.push([...patches]);
+        });
+        state.a = 10;
+        state.b = 20;
+        await Promise.resolve();
+        // Should be called once with all patches batched
+        (0, vitest_1.expect)(patchCalls).toHaveLength(1);
+        (0, vitest_1.expect)(patchCalls[0]).toEqual([
+            { op: "add", path: ["a"], value: 10 },
+            { op: "add", path: ["b"], value: 20 },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("both JIT and batched listeners can coexist on the same root", async () => {
+        const state = (0, __1.deepSignal)({ count: 0 });
+        const jitPatches = [];
+        const batchedPatches = [];
+        const { stopListening: stopJit } = (0, watch_1.watch)(state, ({ patches }) => {
+            jitPatches.push([...patches]);
+        }, { triggerInstantly: true });
+        const { stopListening: stopBatched } = (0, watch_1.watch)(state, ({ patches }) => {
+            batchedPatches.push([...patches]);
+        });
+        state.count = 1;
+        state.count = 2;
+        // JIT should have received 2 calls immediately
+        (0, vitest_1.expect)(jitPatches).toHaveLength(2);
+        // Batched should have received 0 calls so far
+        (0, vitest_1.expect)(batchedPatches).toHaveLength(0);
+        await Promise.resolve();
+        // Now batched should have received 1 call with all patches
+        (0, vitest_1.expect)(batchedPatches).toHaveLength(1);
+        (0, vitest_1.expect)(batchedPatches[0]).toEqual([
+            { op: "add", path: ["count"], value: 1 },
+            { op: "add", path: ["count"], value: 2 },
+        ]);
+        stopJit();
+        stopBatched();
+    });
+    (0, vitest_1.it)("JIT listener works with nested object mutations", () => {
+        const state = (0, __1.deepSignal)({ user: { name: "Alice", age: 30 } });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: p }) => {
+            patches.push([...p]);
+        }, { triggerInstantly: true });
+        state.user.name = "Bob";
+        state.user.age = 31;
+        (0, vitest_1.expect)(patches).toHaveLength(2);
+        (0, vitest_1.expect)(patches[0]).toEqual([
+            { op: "add", path: ["user", "name"], value: "Bob" },
+        ]);
+        (0, vitest_1.expect)(patches[1]).toEqual([
+            { op: "add", path: ["user", "age"], value: 31 },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("JIT listener works with Set mutations", () => {
+        const state = (0, __1.deepSignal)({ items: new Set([1, 2]) });
+        const patches = [];
+        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: p }) => {
+            patches.push([...p]);
+        }, { triggerInstantly: true });
+        state.items.add(3);
+        state.items.delete(1);
+        (0, vitest_1.expect)(patches).toHaveLength(2);
+        (0, vitest_1.expect)(patches[0]).toEqual([
+            { op: "add", path: ["items"], type: "set", value: [3] },
+        ]);
+        (0, vitest_1.expect)(patches[1]).toEqual([
+            { op: "remove", path: ["items"], type: "set", value: 1 },
+        ]);
+        stop();
+    });
+    (0, vitest_1.it)("stopping JIT listener prevents further callbacks", () => {
+        const state = (0, __1.deepSignal)({ value: 0 });
+        let callCount = 0;
+        const { stopListening: stop } = (0, watch_1.watch)(state, () => {
+            callCount++;
+        }, { triggerInstantly: true });
+        state.value = 1;
+        (0, vitest_1.expect)(callCount).toBe(1);
+        stop();
+        state.value = 2;
+        state.value = 3;
+        // Should still be 1, no more calls after stop
+        (0, vitest_1.expect)(callCount).toBe(1);
+    });
+});