@ng-org/alien-deepsignals 0.1.2-alpha.10 → 0.1.2-alpha.12

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

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
 // All rights reserved.
 // Licensed under the Apache License, Version 2.0
@@ -8,153 +7,152 @@
 // 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 deepSignal_1 = require("../../deepSignal");
-(0, vitest_1.describe)("watch", () => {
-    (0, vitest_1.it)("watch immediate", () => {
-        const store = (0, __1.deepSignal)({
+import { describe, it, expect } from "vitest";
+import { deepSignal, addWithId, } from "../../index.js";
+import { watch } from "../../watch.js";
+import { setSetEntrySyntheticId } from "../../deepSignal.js";
+describe("watch", () => {
+    it("watch immediate", () => {
+        const store = deepSignal({
             userinfo: {
                 name: "tom",
             },
         });
         let val;
-        (0, watch_1.watch)(store, ({ newValue }) => {
+        watch(store, ({ newValue }) => {
             val = newValue.userinfo.name;
         }, { immediate: true });
-        (0, vitest_1.expect)(val).toEqual("tom");
+        expect(val).toEqual("tom");
     });
-    (0, vitest_1.it)("watch deep", () => {
-        const store = (0, __1.deepSignal)({
+    it("watch deep", () => {
+        const store = deepSignal({
             userinfo: {
                 name: "tom",
             },
         });
         let val;
-        (0, watch_1.watch)(store, ({ newValue }) => {
+        watch(store, ({ newValue }) => {
             val = newValue.userinfo.name;
         }, { immediate: true });
         let value2;
-        (0, watch_1.watch)(store, ({ newValue }) => {
+        watch(store, ({ newValue }) => {
             value2 = newValue.userinfo.name;
         }, { immediate: true });
-        (0, vitest_1.expect)(val).toEqual("tom");
+        expect(val).toEqual("tom");
         store.userinfo.name = "jon";
         // patch delivery async (microtask)
         return Promise.resolve().then(() => {
-            (0, vitest_1.expect)(val).toEqual("jon");
+            expect(val).toEqual("jon");
             // With refactored watch using native effect, shallow watcher now also updates root reference
-            (0, vitest_1.expect)(value2).toEqual("jon");
+            expect(value2).toEqual("jon");
         });
     });
-    (0, vitest_1.it)("watch once", () => {
-        const store = (0, __1.deepSignal)({
+    it("watch once", () => {
+        const store = deepSignal({
             userinfo: {
                 name: "tom",
             },
         });
         let val;
-        (0, watch_1.watch)(store, ({ newValue }) => {
+        watch(store, ({ newValue }) => {
             val = newValue.userinfo.name;
         }, { immediate: true, once: true });
-        (0, vitest_1.expect)(val).toEqual("tom");
+        expect(val).toEqual("tom");
         store.userinfo.name = "jon";
         // once watcher shouldn't update after first run
-        (0, vitest_1.expect)(val).toEqual("tom");
+        expect(val).toEqual("tom");
     });
-    (0, vitest_1.it)("delivers immediate snapshot", () => {
-        const state = (0, __1.deepSignal)({ user: { name: "tom" } });
+    it("delivers immediate snapshot", () => {
+        const state = deepSignal({ user: { name: "tom" } });
         let observed = "";
-        (0, watch_1.watch)(state, ({ newValue }) => {
+        watch(state, ({ newValue }) => {
             observed = newValue.user.name;
         }, { immediate: true });
-        (0, vitest_1.expect)(observed).toEqual("tom");
+        expect(observed).toEqual("tom");
     });
-    (0, vitest_1.it)("emits patches with version", async () => {
-        const state = (0, __1.deepSignal)({ count: 0 });
+    it("emits patches with version", async () => {
+        const state = deepSignal({ count: 0 });
         const versions = [];
-        (0, watch_1.watch)(state, ({ version }) => {
+        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);
+        expect(versions.length).toBe(1);
+        expect(versions[0]).toBeGreaterThan(0);
     });
 });
-(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 }] });
+describe("watch (patch mode)", () => {
+    it("emits set patches with correct paths and batching", async () => {
+        const state = deepSignal({ a: { b: 1 }, arr: [1, { x: 2 }] });
         const received = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stop } = 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);
+        expect(received).toHaveLength(1);
         const batch = received[0];
-        (0, vitest_1.expect)(batch).toEqual([
+        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)({
+    it("emits delete patches without value", async () => {
+        const state = deepSignal({
             a: { b: 1 },
             c: 2,
         });
         const out = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => out.push(patches));
+        const { stopListening: stop } = 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([
+        expect(out).toHaveLength(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 });
+    it("filters out patches from other roots", async () => {
+        const a = deepSignal({ x: 1 });
+        const b = deepSignal({ y: 2 });
         const out = [];
-        const { stopListening: stop } = (0, watch_1.watch)(a, ({ patches }) => out.push(patches));
+        const { stopListening: stop } = 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 }]);
+        expect(out).toHaveLength(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]) });
+    it("emits patches for Set structural mutations (add/delete)", async () => {
+        const state = deepSignal({ s: new Set([1, 2]) });
         const batches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => batches.push(patches));
+        const { stopListening: stop } = 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([
+        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: {} });
+    it("emits patches for nested objects added after initialization", async () => {
+        const state = deepSignal({ root: {} });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        const { stopListening: stop } = 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([
+        expect(flattened).toEqual([
             { op: "add", path: ["root", "child"], value: {} },
             { op: "add", path: ["root", "child", "level"], value: {} },
             {
@@ -166,28 +164,28 @@ const deepSignal_1 = require("../../deepSignal");
         ]);
         stop();
     });
-    (0, vitest_1.it)("emits patches for Set with primitives added as one operation", async () => {
-        const state = (0, __1.deepSignal)({ container: {} }, {
+    it("emits patches for Set with primitives added as one operation", async () => {
+        const state = deepSignal({ container: {} }, {
             syntheticIdPropertyName: "id",
         });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(...batch));
+        const { stopListening: stop } = 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({
+        expect(patches).toHaveLength(3);
+        expect(patches[0]).toMatchObject({
             op: "add",
             path: ["container", "items"],
             type: "set",
         });
-        (0, vitest_1.expect)(patches[1]).toMatchObject({
+        expect(patches[1]).toMatchObject({
             op: "add",
             path: ["container", "items"],
             type: "set",
             value: ["item1"],
         });
-        (0, vitest_1.expect)(patches[2]).toMatchObject({
+        expect(patches[2]).toMatchObject({
             op: "add",
             path: ["container", "items"],
             type: "set",
@@ -195,10 +193,10 @@ const deepSignal_1 = require("../../deepSignal");
         });
         stop();
     });
-    (0, vitest_1.it)("emits patches for deeply nested arrays and objects", async () => {
-        const state = (0, __1.deepSignal)({ data: null });
+    it("emits patches for deeply nested arrays and objects", async () => {
+        const state = deepSignal({ data: null });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        const { stopListening: stop } = watch(state, ({ patches: batch }) => patches.push(batch));
         state.data = {
             users: [
                 {
@@ -214,7 +212,7 @@ const deepSignal_1 = require("../../deepSignal");
         };
         await Promise.resolve();
         const flattened = patches.flat();
-        (0, vitest_1.expect)(flattened).toEqual([
+        expect(flattened).toEqual([
             { op: "add", path: ["data"], value: {}, type: undefined },
             { op: "add", path: ["data", "users"], value: [], type: undefined },
             {
@@ -285,20 +283,20 @@ const deepSignal_1 = require("../../deepSignal");
         ]);
         stop();
     });
-    (0, vitest_1.it)("emits patches for Set with nested objects added as one operation", async () => {
-        const state = (0, __1.deepSignal)({ container: {} }, {
+    it("emits patches for Set with nested objects added as one operation", async () => {
+        const state = deepSignal({ container: {} }, {
             syntheticIdPropertyName: "id",
             propGenerator: ({ object }) => ({ syntheticId: object.id }),
         });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        const { stopListening: stop } = 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([
+        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" },
@@ -337,28 +335,28 @@ const deepSignal_1 = require("../../deepSignal");
         ]);
         stop();
     });
-    (0, vitest_1.it)("emits structural patches for sets of sets", async () => {
+    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 state = deepSignal({ graph: s });
         const batches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => batches.push(patches));
+        const { stopListening: stop } = 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);
+        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 () => {
+    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]) }, {
+        const st = 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));
+        const { stopListening: stop } = watch(st, ({ patches }) => collected.push(patches));
         let proxied;
         for (const e of st.bag.values()) {
             proxied = e;
@@ -367,21 +365,21 @@ const deepSignal_1 = require("../../deepSignal");
         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);
+        expect(flat.some((p) => p.endsWith("n1.data.val"))).toBe(true);
         stop();
     });
-    (0, vitest_1.it)("allows custom synthetic id for Set entry", async () => {
+    it("allows custom synthetic id for Set entry", async () => {
         const node = { name: "x" };
-        const state = (0, __1.deepSignal)({ s: new Set() });
+        const state = 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");
+        const { stopListening: stop } = watch(state, ({ patches }) => collected2.push(patches));
+        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);
+        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 () => {
+    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
@@ -397,123 +395,123 @@ const deepSignal_1 = require("../../deepSignal");
                 };
             },
         };
-        const state = (0, __1.deepSignal)(new Set(), options);
+        const state = deepSignal(new Set(), options);
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+        const { stopListening: stop } = 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");
+        expect(newObj["@id"]).toBeDefined();
+        expect(newObj["@graph"]).toBeDefined();
+        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");
+        expect(idPatch).toBeDefined();
+        expect(idPatch?.op).toBe("add");
+        expect(idPatch?.value).toBeDefined();
+        expect(idPatch?.value?.startsWith("did:ng:test-subject")).toBeTruthy();
+        expect(graphPatch).toBeDefined();
+        expect(graphPatch?.op).toBe("add");
+        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() });
+    describe("Set", () => {
+        it("emits patches for primitive adds", async () => {
+            const st = deepSignal({ s: new Set() });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            expect(batches.length).toBe(1);
             const patches = batches[0];
-            (0, vitest_1.expect)(patches.length).toBe(3);
+            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");
+                expect(p.path.join(".")).toBe("s");
+                expect(p.op).toBe("add");
+                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");
+            expect(values).toContain(true);
+            expect(values).toContain(2);
+            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"]) });
+        it("emits patches for primitive deletes", async () => {
+            const st = deepSignal({ s: new Set([true, 2, "3"]) });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            expect(batches.length).toBe(1);
             const patches = batches[0];
-            (0, vitest_1.expect)(patches.length).toBe(2);
+            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");
+                expect(p.path.join(".")).toBe("s");
+                expect(p.op).toBe("remove");
+                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);
+            expect(values).toContain(true);
+            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]) });
+        it("does not emit patches for non-existent primitives", async () => {
+            const st = deepSignal({ s: new Set([1, 2]) });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            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]) });
+        it("does not emit patches for already added primitive", async () => {
+            const st = deepSignal({ s: new Set([1, "test", true]) });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            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");
+        it("emits single structural patch on Set.clear()", async () => {
+            const st = deepSignal({ s: new Set() });
+            addWithId(st.s, { id: "a", x: 1 }, "a");
+            addWithId(st.s, { id: "b", x: 2 }, "b");
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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([]);
+            expect(structuralPatches.length).toBe(1);
+            expect(structuralPatches[0].op).toBe("add");
+            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() }, {
+        it("emits delete patch for object entry", async () => {
+            const st = 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));
+            const { stopListening: stop } = watch(st, ({ patches: batch }) => patches.push(batch));
             st.s.add(obj);
             st.s.delete(obj);
             await Promise.resolve();
@@ -521,94 +519,94 @@ const deepSignal_1 = require("../../deepSignal");
                 .flat()
                 .filter((p) => p.op === "remove")
                 .map((p) => p.path.join("."));
-            (0, vitest_1.expect)(all).toContain("s.n1");
+            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]) });
+        it("does not emit patch for duplicate add", async () => {
+            const st = deepSignal({ s: new Set([1]) });
             const patches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            const { stopListening: stop } = watch(st, ({ patches: batch }) => patches.push(batch));
             st.s.add(1);
             await Promise.resolve();
-            (0, vitest_1.expect)(patches.length).toBe(0);
+            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]) });
+        it("does not emit patch deleting non-existent entry", async () => {
+            const st = deepSignal({ s: new Set([1]) });
             const patches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            const { stopListening: stop } = watch(st, ({ patches: batch }) => patches.push(batch));
             st.s.delete(2);
             await Promise.resolve();
-            (0, vitest_1.expect)(patches.length).toBe(0);
+            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() });
+        it("addWithId primitive returns primitive and emits patch with primitive key", async () => {
+            const st = 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);
+            const { stopListening: stop } = watch(st, ({ patches: batch }) => patches.push(batch));
+            const ret = addWithId(st.s, 5, "ignored");
+            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");
+            expect(paths).toContain("s");
             const values = patches.flat().map((p) => p.value?.[0]);
-            (0, vitest_1.expect)(values).toContain(5);
+            expect(values).toContain(5);
             stop();
         });
-        (0, vitest_1.it)("setSetEntrySyntheticId applies custom id without helper", async () => {
-            const st = (0, __1.deepSignal)({ s: new Set() });
+        it("setSetEntrySyntheticId applies custom id without helper", async () => {
+            const st = deepSignal({ s: new Set() });
             const obj = { name: "x" };
-            (0, deepSignal_1.setSetEntrySyntheticId)(obj, "customX");
+            setSetEntrySyntheticId(obj, "customX");
             const patches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches: batch }) => patches.push(batch));
+            const { stopListening: stop } = 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");
+            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");
+        it("values/entries/forEach proxy nested mutation", async () => {
+            const st = deepSignal({ s: new Set() });
+            const entry = addWithId(st.s, { id: "e1", inner: { v: 1 } }, "e1");
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            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 () => {
+        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]) }, {
+            const st = 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));
+            const { stopListening: stop } = 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);
+            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);
+            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() });
+        it("synthetic id collision assigns unique blank node id", async () => {
+            const st = 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));
+            const { stopListening: stop } = watch(st, ({ patches: batch }) => patches.push(batch));
             st.s.add(a1);
             st.s.add(a2);
             await Promise.resolve();
@@ -620,11 +618,11 @@ const deepSignal_1 = require("../../deepSignal");
                 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);
+            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)({
+        it("allows Array.from() and spread on Set without brand errors and tracks nested mutation", async () => {
+            const st = deepSignal({
                 s: new Set([{ id: "eIter", inner: { v: 1 } }]),
             }, {
                 syntheticIdPropertyName: "id",
@@ -632,50 +630,50 @@ const deepSignal_1 = require("../../deepSignal");
             });
             // 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);
+            expect(arr.length).toBe(1);
+            expect(arr[0].inner.v).toBe(1);
             const spread = [...st.s];
-            (0, vitest_1.expect)(spread[0].inner.v).toBe(1);
+            expect(spread[0].inner.v).toBe(1);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            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());
+        it("generates correct patches when root is a Set (primitive entries)", async () => {
+            const rootSet = deepSignal(new Set());
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(rootSet, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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);
+            expect(batches.length).toBe(1);
             const patches = batches[0];
-            (0, vitest_1.expect)(patches.length).toBe(3);
+            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");
+                expect(p.path).toEqual([]);
+                expect(p.op).toBe("add");
+                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);
+            expect(values).toContain(1);
+            expect(values).toContain("test");
+            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(), {
+        it("generates correct patches when root is a Set (object entries)", async () => {
+            const rootSet = 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 { stopListening: stop } = watch(rootSet, ({ patches }) => batches.push(patches));
             const obj1 = { "@id": "obj1", value: 1 };
             const obj2 = { "@id": "obj2", value: 2 };
             rootSet.add(obj1);
@@ -683,23 +681,23 @@ const deepSignal_1 = require("../../deepSignal");
             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");
+            expect(flat).toContain("obj1");
+            expect(flat).toContain("obj1.@id");
+            expect(flat).toContain("obj1.value");
+            expect(flat).toContain("obj2");
+            expect(flat).toContain("obj2.@id");
+            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(), {
+        it("tracks nested mutations when root is a Set", async () => {
+            const rootSet = 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));
+            const { stopListening: stop } = watch(rootSet, ({ patches }) => batches.push(patches));
             // Get the proxied entry
             let proxied;
             for (const e of rootSet.values()) {
@@ -708,23 +706,23 @@ const deepSignal_1 = require("../../deepSignal");
             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);
+            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] });
+    describe("Arrays & mixed batch", () => {
+        it("emits patches for splice/unshift/shift in single batch", async () => {
+            const st = deepSignal({ arr: [1, 2, 3] });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => {
+            const { stopListening: stop } = 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([
+            expect(st.arr).toEqual([1, 99, 100, 3]);
+            expect(batches[0]).toEqual([
                 { path: ["arr", "1"], op: "remove" },
                 { path: ["arr", "1"], op: "add", value: 100 },
                 { path: ["arr", "1"], op: "add", value: 99 },
@@ -733,15 +731,15 @@ const deepSignal_1 = require("../../deepSignal");
             ]);
             stop();
         });
-        (0, vitest_1.it)("emits patches adding new array", async () => {
-            const obj = (0, __1.deepSignal)({});
+        it("emits patches adding new array", async () => {
+            const obj = deepSignal({});
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(obj, ({ patches }) => {
+            const { stopListening: stop } = watch(obj, ({ patches }) => {
                 batches.push(patches);
             });
             obj.arr = [1, 2, 3];
             await Promise.resolve();
-            (0, vitest_1.expect)(batches[0]).toEqual([
+            expect(batches[0]).toEqual([
                 { path: ["arr"], op: "add", value: [] },
                 { path: ["arr", 0], op: "add", value: 1 },
                 { path: ["arr", 1], op: "add", value: 2 },
@@ -749,42 +747,42 @@ const deepSignal_1 = require("../../deepSignal");
             ]);
             stop();
         });
-        (0, vitest_1.it)("emits remove patches when array length shrinks", async () => {
-            const st = (0, __1.deepSignal)([1, 0, 3, -1]);
+        it("emits remove patches when array length shrinks", async () => {
+            const st = deepSignal([1, 0, 3, -1]);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => {
+            const { stopListening: stop } = 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([
+            expect(st).toEqual([1, 0]);
+            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() });
+        it("mixed object/array/Set mutations batch together", async () => {
+            const st = deepSignal({ o: { a: 1 }, arr: [1], s: new Set() });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = watch(st, ({ patches }) => batches.push(patches));
             st.o.a = 2;
             st.arr.push(2);
-            (0, __1.addWithId)(st.s, { id: "z", v: 1 }, "z");
+            addWithId(st.s, { id: "z", v: 1 }, "z");
             await Promise.resolve();
-            (0, vitest_1.expect)(batches.length).toBe(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);
+            expect(paths).toContain("o.a");
+            expect(paths).toContain("arr.1");
+            expect(paths.some((p) => p.startsWith("s."))).toBe(true);
             stop();
         });
-        (0, vitest_1.it)("mutating existing Set property emits correct patches", async () => {
+        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]) }, {
+            const st = deepSignal({ items: new Set([obj2]) }, {
                 syntheticIdPropertyName: "@id",
                 propGenerator: ({ object }) => ({
                     syntheticId: object["@id"],
@@ -796,7 +794,7 @@ const deepSignal_1 = require("../../deepSignal");
                 proxiedObj = item;
             }
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = watch(st, ({ patches }) => batches.push(patches));
             // Modify the Set property: remove one value and add another
             proxiedObj.setProperty.delete(3);
             proxiedObj.setProperty.add(4);
@@ -805,25 +803,25 @@ const deepSignal_1 = require("../../deepSignal");
             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);
+            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);
+            expect(removePatches.length).toBe(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);
+            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);
+            expect(addedValues).toContain(4);
+            expect(addedValues).toContain(5);
             stop();
         });
-        (0, vitest_1.it)("reassigning Set property should not emit deep patches for all elements", async () => {
+        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]) }, {
+            const st = deepSignal({ items: new Set([obj2]) }, {
                 syntheticIdPropertyName: "@id",
                 propGenerator: ({ object }) => ({
                     syntheticId: object["@id"],
@@ -835,7 +833,7 @@ const deepSignal_1 = require("../../deepSignal");
                 proxiedObj = item;
             }
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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();
@@ -853,22 +851,22 @@ const deepSignal_1 = require("../../deepSignal");
             // 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);
+            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);
+            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();
+            expect(patch6).toBeDefined();
             stop();
         });
-        (0, vitest_1.it)("calls propGenerator for objects with nested Set structures (Set inside Set)", async () => {
+        it("calls propGenerator for objects with nested Set structures (Set inside Set)", async () => {
             const propGeneratorCalls = [];
-            const st = (0, __1.deepSignal)({ items: new Set() }, {
+            const st = deepSignal({ items: new Set() }, {
                 syntheticIdPropertyName: "@id",
                 propGenerator: ({ object, path, inSet }) => {
                     propGeneratorCalls.push({ object, path, inSet });
@@ -878,7 +876,7 @@ const deepSignal_1 = require("../../deepSignal");
                 },
             });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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" };
@@ -892,29 +890,29 @@ const deepSignal_1 = require("../../deepSignal");
             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");
+            expect(outerCall).toBeDefined();
+            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");
+            expect(inner1Call).toBeDefined();
+            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");
+            expect(inner2Call).toBeDefined();
+            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);
+            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);
+            expect(flat.some((p) => p.includes("nestedSet"))).toBe(true);
+            expect(flat.some((p) => p.includes("inner1"))).toBe(true);
+            expect(flat.some((p) => p.includes("inner2"))).toBe(true);
             stop();
         });
-        (0, vitest_1.it)("calls propGenerator for deeply nested Sets (multiple levels)", async () => {
+        it("calls propGenerator for deeply nested Sets (multiple levels)", async () => {
             const propGeneratorCalls = [];
-            const st = (0, __1.deepSignal)(new Set(), {
+            const st = deepSignal(new Set(), {
                 syntheticIdPropertyName: "@id",
                 propGenerator: ({ object, path, inSet }) => {
                     propGeneratorCalls.push({ object, path, inSet });
@@ -924,7 +922,7 @@ const deepSignal_1 = require("../../deepSignal");
                 },
             });
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(st, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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
@@ -937,8 +935,8 @@ const deepSignal_1 = require("../../deepSignal");
             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);
+            expect(propGeneratorCalls.some((call) => call.object === outerObj)).toBe(true);
+            expect(propGeneratorCalls.some((call) => call.object === innerObj)).toBe(true);
             // Clear batches for mutation test
             batches.length = 0;
             // Get proxied objects through iteration
@@ -957,49 +955,49 @@ const deepSignal_1 = require("../../deepSignal");
             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();
+            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");
+            expect(pathSegments?.length).toBe(4);
+            expect(pathSegments?.[0]).toBe("outerId-withCustomString");
+            expect(pathSegments?.[1]).toBe("anotherObject");
+            expect(pathSegments?.[2]).toBe("innerId-withCustomString");
+            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]);
+        it("Does not mutate calling .sort() and .reverse()", async () => {
+            const signalObject = deepSignal([1, 3, 2]);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = watch(signalObject, ({ patches }) => batches.push(patches));
             signalObject.sort();
             signalObject.reverse();
-            (0, vitest_1.expect)(signalObject).toEqual([1, 3, 2]);
+            expect(signalObject).toEqual([1, 3, 2]);
             await Promise.resolve();
-            (0, vitest_1.expect)(batches).toHaveLength(0);
+            expect(batches).toHaveLength(0);
             stop();
         });
-        (0, vitest_1.it)("Emits patches on .shift()", async () => {
-            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+        it("Emits patches on .shift()", async () => {
+            const signalObject = deepSignal([1, 3, 2]);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = watch(signalObject, ({ patches }) => batches.push(patches));
             signalObject.shift();
-            (0, vitest_1.expect)(signalObject).toEqual([3, 2]);
+            expect(signalObject).toEqual([3, 2]);
             await Promise.resolve();
-            (0, vitest_1.expect)(batches[0]).toEqual([
+            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]);
+        it("Emits patches on .splice()", async () => {
+            const signalObject = deepSignal([1, 3, 2]);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = 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([
+            expect(signalObject).toEqual([1, 10, 2]);
+            expect(batches[0]).toEqual([
                 {
                     op: "remove",
                     path: ["1"],
@@ -1011,14 +1009,14 @@ const deepSignal_1 = require("../../deepSignal");
                 },
             ]);
         });
-        (0, vitest_1.it)("Does not mutate calling .unshift()", async () => {
-            const signalObject = (0, __1.deepSignal)([1, 3, 2]);
+        it("Does not mutate calling .unshift()", async () => {
+            const signalObject = deepSignal([1, 3, 2]);
             const batches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(signalObject, ({ patches }) => batches.push(patches));
+            const { stopListening: stop } = watch(signalObject, ({ patches }) => batches.push(patches));
             signalObject.unshift(-1, 0);
-            (0, vitest_1.expect)(signalObject).toEqual([-1, 0, 1, 3, 2]);
+            expect(signalObject).toEqual([-1, 0, 1, 3, 2]);
             await Promise.resolve();
-            (0, vitest_1.expect)(batches[0]).toEqual([
+            expect(batches[0]).toEqual([
                 {
                     op: "add",
                     path: ["0"],
@@ -1032,17 +1030,17 @@ const deepSignal_1 = require("../../deepSignal");
             ]);
         });
     });
-    (0, vitest_1.describe)("delete patches", () => {
-        (0, vitest_1.it)("emits delete patch when removing objects with @id from Sets", async () => {
+    describe("delete patches", () => {
+        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 state = deepSignal({ s: new Set() }, options);
             const patches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            const { stopListening: stop } = 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 };
@@ -1064,19 +1062,19 @@ const deepSignal_1 = require("../../deepSignal");
                 .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");
+            expect(deletePaths).toContain("s.obj-2");
+            expect(deletePaths).not.toContain("s.obj-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 () => {
+        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);
+            const state = deepSignal({ s: new Set() }, options);
             // Add objects without @id - they should get generated IDs
             const obj1 = { value: 1 };
             const obj2 = { value: 2 };
@@ -1088,10 +1086,10 @@ const deepSignal_1 = require("../../deepSignal");
             const proxiedObj2 = proxiedObjs[1];
             const id1 = proxiedObj1["@id"];
             const id2 = proxiedObj2["@id"];
-            (0, vitest_1.expect)(id1).toBeDefined();
-            (0, vitest_1.expect)(id2).toBeDefined();
+            expect(id1).toBeDefined();
+            expect(id2).toBeDefined();
             const patches = [];
-            const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: batch }) => patches.push(batch));
+            const { stopListening: stop } = watch(state, ({ patches: batch }) => patches.push(batch));
             // Delete one object using the proxied object
             state.s.delete(proxiedObj1);
             await Promise.resolve();
@@ -1100,172 +1098,172 @@ const deepSignal_1 = require("../../deepSignal");
                 .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}`);
+            expect(deletePaths).toContain(`s.${id1}`);
+            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 });
+describe("watch (triggerInstantly / JIT listeners)", () => {
+    it("triggers callback synchronously when triggerInstantly is true", () => {
+        const state = deepSignal({ count: 0 });
         const callTimes = [];
         let syncMarker = 0;
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stop } = 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]);
+        expect(callTimes).toEqual([1]);
         stop();
     });
-    (0, vitest_1.it)("triggers callback asynchronously when triggerInstantly is false", async () => {
-        const state = (0, __1.deepSignal)({ count: 0 });
+    it("triggers callback asynchronously when triggerInstantly is false", async () => {
+        const state = deepSignal({ count: 0 });
         const callTimes = [];
         let syncMarker = 0;
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stop } = 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([]);
+        expect(callTimes).toEqual([]);
         await Promise.resolve();
         // Now callback should have been called (at syncMarker = 2)
-        (0, vitest_1.expect)(callTimes).toEqual([2]);
+        expect(callTimes).toEqual([2]);
         stop();
     });
-    (0, vitest_1.it)("JIT listener receives patches without version", () => {
-        const state = (0, __1.deepSignal)({ value: "initial" });
+    it("JIT listener receives patches without version", () => {
+        const state = deepSignal({ value: "initial" });
         let receivedVersion = 999; // sentinel value
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches, version }) => {
+        const { stopListening: stop } = 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();
+        expect(receivedVersion).toBeUndefined();
         stop();
     });
-    (0, vitest_1.it)("batched listener receives patches with version", async () => {
-        const state = (0, __1.deepSignal)({ value: "initial" });
+    it("batched listener receives patches with version", async () => {
+        const state = deepSignal({ value: "initial" });
         let receivedVersion;
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches, version }) => {
+        const { stopListening: stop } = 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);
+        expect(receivedVersion).toBeDefined();
+        expect(typeof receivedVersion).toBe("number");
+        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 });
+    it("JIT listener is called for each mutation, not batched", () => {
+        const state = deepSignal({ a: 1, b: 2 });
         const patchCalls = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stop } = 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 }]);
+        expect(patchCalls).toHaveLength(2);
+        expect(patchCalls[0]).toEqual([{ op: "add", path: ["a"], value: 10 }]);
+        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 });
+    it("batched listener receives all mutations in one batch", async () => {
+        const state = deepSignal({ a: 1, b: 2 });
         const patchCalls = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stop } = 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([
+        expect(patchCalls).toHaveLength(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 });
+    it("both JIT and batched listeners can coexist on the same root", async () => {
+        const state = deepSignal({ count: 0 });
         const jitPatches = [];
         const batchedPatches = [];
-        const { stopListening: stopJit } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stopJit } = watch(state, ({ patches }) => {
             jitPatches.push([...patches]);
         }, { triggerInstantly: true });
-        const { stopListening: stopBatched } = (0, watch_1.watch)(state, ({ patches }) => {
+        const { stopListening: stopBatched } = 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);
+        expect(jitPatches).toHaveLength(2);
         // Batched should have received 0 calls so far
-        (0, vitest_1.expect)(batchedPatches).toHaveLength(0);
+        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([
+        expect(batchedPatches).toHaveLength(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 } });
+    it("JIT listener works with nested object mutations", () => {
+        const state = deepSignal({ user: { name: "Alice", age: 30 } });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: p }) => {
+        const { stopListening: stop } = 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([
+        expect(patches).toHaveLength(2);
+        expect(patches[0]).toEqual([
             { op: "add", path: ["user", "name"], value: "Bob" },
         ]);
-        (0, vitest_1.expect)(patches[1]).toEqual([
+        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]) });
+    it("JIT listener works with Set mutations", () => {
+        const state = deepSignal({ items: new Set([1, 2]) });
         const patches = [];
-        const { stopListening: stop } = (0, watch_1.watch)(state, ({ patches: p }) => {
+        const { stopListening: stop } = 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([
+        expect(patches).toHaveLength(2);
+        expect(patches[0]).toEqual([
             { op: "add", path: ["items"], type: "set", value: [3] },
         ]);
-        (0, vitest_1.expect)(patches[1]).toEqual([
+        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 });
+    it("stopping JIT listener prevents further callbacks", () => {
+        const state = deepSignal({ value: 0 });
         let callCount = 0;
-        const { stopListening: stop } = (0, watch_1.watch)(state, () => {
+        const { stopListening: stop } = watch(state, () => {
             callCount++;
         }, { triggerInstantly: true });
         state.value = 1;
-        (0, vitest_1.expect)(callCount).toBe(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);
+        expect(callCount).toBe(1);
     });
 });