signalium 2.2.2 → 2.3.0

package/dist/esm/development/snapshot-Bq0Um_hQ.js

@@ -0,0 +1,148 @@
+import { c as createReactiveDefinition, S as SignalScope, g as getCurrentScope, a as createReactiveSignal, b as createTask, d as createRelay, e as getScopeOwner, i as isReactivePromise } from "./debug-AoHfqs62.js";
+const DERIVED_DEFINITION_MAP = /* @__PURE__ */ new WeakMap();
+function getReactiveFnAndDefinition(fn, opts) {
+  let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);
+  if (!fnAndDef) {
+    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, void 0);
+    const defScope = getCurrentScope();
+    const reactiveFn = (...args) => {
+      const scope = getCurrentScope(defScope);
+      const signal = scope.get(def, args);
+      return signal.value;
+    };
+    fnAndDef = [reactiveFn, def];
+    DERIVED_DEFINITION_MAP.set(fn, fnAndDef);
+  }
+  return fnAndDef;
+}
+function reactive(fn, opts) {
+  return getReactiveFnAndDefinition(fn, opts)[0];
+}
+const reactiveMethod = (owner, fn, opts) => {
+  const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, void 0);
+  const reactiveFn = (...args) => {
+    return getScopeOwner(owner).get(def, args).value;
+  };
+  DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);
+  return reactiveFn;
+};
+function relay(activate, opts) {
+  const scope = getCurrentScope();
+  return createRelay(activate, scope, opts);
+}
+const task = (fn, opts) => {
+  const scope = getCurrentScope();
+  return createTask(fn, scope, opts);
+};
+function watcher(fn, opts) {
+  const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, void 0, opts?.tracer);
+  const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();
+  return createReactiveSignal(def, void 0, void 0, scope);
+}
+const reactiveSignal = (compute, opts) => {
+  const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, void 0, void 0);
+  const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();
+  return createReactiveSignal(def, void 0, void 0, scope);
+};
+const getProto = Object.getPrototypeOf;
+function snapshotArray(current, prev, snap) {
+  const prevArr = Array.isArray(prev) ? prev : void 0;
+  let changed = !prevArr || prevArr.length !== current.length;
+  const result = new Array(current.length);
+  for (let i = 0; i < current.length; i++) {
+    result[i] = snap(current[i], prevArr?.[i]);
+    if (!changed && result[i] !== prevArr[i]) {
+      changed = true;
+    }
+  }
+  return changed ? result : prevArr;
+}
+function snapshotPlainObject(current, prev, snap) {
+  const prevObj = prev !== null && prev !== void 0 && typeof prev === "object" && !Array.isArray(prev) ? prev : void 0;
+  const keys = Object.keys(current);
+  let changed = !prevObj || Object.keys(prevObj).length !== keys.length;
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    result[key] = snap(current[key], prevObj?.[key]);
+    if (!changed && result[key] !== prevObj[key]) {
+      changed = true;
+    }
+  }
+  return changed ? result : prevObj;
+}
+function snapshotReactivePromise(current, prev, snap) {
+  const prevObj = prev !== null && prev !== void 0 && typeof prev === "object" ? prev : void 0;
+  const value = snap(current.value, prevObj?.value);
+  const error = current.error;
+  const isPending = current.isPending;
+  const isRejected = current.isRejected;
+  const isResolved = current.isResolved;
+  const isReady = current.isReady;
+  const isSettled = current.isSettled;
+  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled) {
+    return prevObj;
+  }
+  return { value, error, isPending, isRejected, isResolved, isReady, isSettled };
+}
+function snapshotMap(current, prev, snap) {
+  const prevMap = prev instanceof Map ? prev : void 0;
+  let changed = !prevMap || prevMap.size !== current.size;
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, val] of current) {
+    const snapped = snap(val, prevMap?.get(key));
+    result.set(key, snapped);
+    if (!changed && snapped !== prevMap.get(key)) {
+      changed = true;
+    }
+  }
+  return changed ? result : prevMap;
+}
+function snapshotSet(current, prev, _snap) {
+  const prevSet = prev instanceof Set ? prev : void 0;
+  let changed = !prevSet || prevSet.size !== current.size;
+  const result = /* @__PURE__ */ new Set();
+  for (const val of current) {
+    const snapped = snapshot(val, prevSet?.has(val) ? val : void 0);
+    result.add(snapped);
+    if (!changed && !prevSet.has(snapped)) {
+      changed = true;
+    }
+  }
+  return changed ? result : prevSet;
+}
+const PROTO_TO_SNAPSHOT = /* @__PURE__ */ new Map([
+  [Object.prototype, snapshotPlainObject],
+  [Array.prototype, snapshotArray],
+  [Map.prototype, snapshotMap],
+  [Set.prototype, snapshotSet],
+  [null, snapshotPlainObject]
+]);
+const registerCustomSnapshot = (ctor, snapshotFn) => {
+  PROTO_TO_SNAPSHOT.set(ctor.prototype, snapshotFn);
+};
+function snapshot(currentValue, prevValue) {
+  if (currentValue === null || typeof currentValue !== "object") {
+    return currentValue;
+  }
+  if (isReactivePromise(currentValue)) {
+    return snapshotReactivePromise(currentValue, prevValue, snapshot);
+  }
+  const handler = PROTO_TO_SNAPSHOT.get(getProto(currentValue));
+  if (handler !== void 0) {
+    return handler(currentValue, prevValue, snapshot);
+  }
+  return currentValue;
+}
+export {
+  registerCustomSnapshot as a,
+  reactive as b,
+  reactiveMethod as c,
+  relay as d,
+  getReactiveFnAndDefinition as g,
+  reactiveSignal as r,
+  snapshot as s,
+  task as t,
+  watcher as w
+};
+//# sourceMappingURL=snapshot-Bq0Um_hQ.js.map

package/dist/esm/development/snapshot-Bq0Um_hQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-Bq0Um_hQ.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\nconst PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    PROTO_TO_SNAPSHOT.set(ctor.prototype, snapshotFn);\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances (non-plain prototypes) are returned as-is unless a custom handler is registered.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    const handler = PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (handler !== undefined) {\n        return handler(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/development/transform/index.js

@@ -19,53 +19,56 @@ const createTransformedImports = (defaultImports, additionalImports, globalImpor
   return transformedImports;
 };
 function createSignaliumAsyncTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["callback", ["signalium"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]],
-      ["watcher", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["callback", ["signalium"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    return importPaths.some(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    return importPaths.some((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
   };
   const isReactiveCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return isTrackedImport(callee.name, path);
   };
   const isWithinTrackedCall = (path) => {
     let current = path.parentPath;
     while (current) {
-      if (current.isCallExpression() && isReactiveCall(current)) return true;
+      if (current.isCallExpression() && isReactiveCall(current))
+        return true;
       current = current.parentPath;
     }
     return false;
   };
   function convertReactiveToGenerator(path) {
-    if (!isWithinTrackedCall(path)) return;
-    if (!path.node.async) return;
+    if (!isWithinTrackedCall(path))
+      return;
+    if (!path.node.async)
+      return;
     path.traverse({
       AwaitExpression(awaitPath) {
         const funcParent = awaitPath.getFunctionParent();
-        if (funcParent?.node !== path.node) return;
+        if (funcParent?.node !== path.node)
+          return;
         awaitPath.replaceWith(t.yieldExpression(awaitPath.node.argument));
       }
     });
@@ -103,37 +106,37 @@ function signaliumAsyncTransform(apiOrOpts, maybeOpts) {
   return (api) => createSignaliumAsyncTransform(api, apiOrOpts);
 }
 function createSignaliumCallbackTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["component", ["signalium/react"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["component", ["signalium/react"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const callbackImportPath = opts?.callbackImportPath ?? "signalium";
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    const matches = importPaths.find(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    const matches = importPaths.find((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
     return matches ? typeof matches === "string" ? matches : importDecl.source.value : false;
   };
   const isTargetWrapperCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return !!isTrackedImport(callee.name, path);
   };
   function isIdentifierInTypePosition(refPath) {
@@ -143,7 +146,8 @@ function createSignaliumCallbackTransform(api, opts) {
       const nodeType = current.node.type;
       if (nodeType && nodeType.startsWith("TS")) {
         if (current.isTSAsExpression() || current.isTSSatisfiesExpression?.() || current.isTSNonNullExpression() || current.isTSInstantiationExpression?.()) {
-          if (child.key === "expression") return false;
+          if (child.key === "expression")
+            return false;
           return true;
         }
         return true;
@@ -155,9 +159,11 @@ function createSignaliumCallbackTransform(api, opts) {
   }
   function ensureCallbackIdentifier(programPath) {
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const importDecl2 = bodyPath.node;
-      if (importDecl2.source.value !== callbackImportPath) continue;
+      if (importDecl2.source.value !== callbackImportPath)
+        continue;
       for (const spec of importDecl2.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const ispec = spec;
@@ -169,18 +175,17 @@ function createSignaliumCallbackTransform(api, opts) {
       }
     }
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const node = bodyPath.node;
-      if (node.source.value !== callbackImportPath) continue;
+      if (node.source.value !== callbackImportPath)
+        continue;
       const localName2 = programPath.scope.generateUidIdentifier("callback").name;
       node.specifiers.push(t.importSpecifier(t.identifier(localName2), t.identifier("callback")));
       return localName2;
     }
     const localName = "callback";
-    const importDecl = t.importDeclaration(
-      [t.importSpecifier(t.identifier(localName), t.identifier("callback"))],
-      t.stringLiteral(callbackImportPath)
-    );
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(localName), t.identifier("callback"))], t.stringLiteral(callbackImportPath));
     const [first] = programPath.get("body");
     if (first) {
       first.insertBefore(importDecl);
@@ -196,18 +201,24 @@ function createSignaliumCallbackTransform(api, opts) {
     innerFn.traverse({
       ReferencedIdentifier(refPath) {
         const nearestFn = refPath.getFunctionParent();
-        if (!nearestFn || nearestFn.node !== innerNode) return;
+        if (!nearestFn || nearestFn.node !== innerNode)
+          return;
         const name = refPath.node.name;
         const binding = refPath.scope.getBinding(name);
-        if (!binding) return;
-        if (isIdentifierInTypePosition(refPath)) return;
-        if (binding.scope.path.isProgram()) return;
+        if (!binding)
+          return;
+        if (isIdentifierInTypePosition(refPath))
+          return;
+        if (binding.scope.path.isProgram())
+          return;
         let declScope = binding.scope;
         while (declScope) {
-          if (declScope === innerScope) return;
+          if (declScope === innerScope)
+            return;
           declScope = declScope.parent;
         }
-        if (binding.kind === "param" && binding.scope === innerScope) return;
+        if (binding.kind === "param" && binding.scope === innerScope)
+          return;
         depNames.add(name);
       }
     });
@@ -217,10 +228,13 @@ function createSignaliumCallbackTransform(api, opts) {
     name: "signalium-transform-callback-wrapping",
     visitor: {
       CallExpression(callPath) {
-        if (!isTargetWrapperCall(callPath)) return;
+        if (!isTargetWrapperCall(callPath))
+          return;
         const arg0 = callPath.get("arguments")[0];
-        if (!arg0) return;
-        if (!(arg0.isFunctionExpression() || arg0.isArrowFunctionExpression())) return;
+        if (!arg0)
+          return;
+        if (!(arg0.isFunctionExpression() || arg0.isArrowFunctionExpression()))
+          return;
         const outerFn = arg0;
         const programPath = callPath.findParent((p) => p.isProgram());
         const callbackName = ensureCallbackIdentifier(programPath);
@@ -235,10 +249,12 @@ function createSignaliumCallbackTransform(api, opts) {
           // Initialize counters for any function-like node when first seen
           FunctionExpression: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerFnPath) {
-              if (innerFnPath.node === outerFn.node) return;
+              if (innerFnPath.node === outerFn.node)
+                return;
               const immediateParent = innerFnPath.parentPath;
               if (immediateParent && immediateParent.isCallExpression()) {
                 const callee = immediateParent.node.callee;
@@ -285,10 +301,12 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           ArrowFunctionExpression: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerFnPath) {
-              if (innerFnPath.node === outerFn.node) return;
+              if (innerFnPath.node === outerFn.node)
+                return;
               const immediateParent = innerFnPath.parentPath;
               if (immediateParent && immediateParent.isCallExpression()) {
                 const callee = immediateParent.node.callee;
@@ -335,18 +353,14 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           FunctionDeclaration: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerDeclPath) {
               const id = innerDeclPath.node.id;
-              if (!id) return;
-              const fnExpr = t.functionExpression(
-                id,
-                innerDeclPath.node.params,
-                innerDeclPath.node.body,
-                innerDeclPath.node.generator,
-                innerDeclPath.node.async
-              );
+              if (!id)
+                return;
+              const fnExpr = t.functionExpression(id, innerDeclPath.node.params, innerDeclPath.node.body, innerDeclPath.node.generator, innerDeclPath.node.async);
               const deps = Array.from(collectDeps(innerDeclPath));
               const parentFn = innerDeclPath.parentPath?.getFunctionParent() || outerFn;
               const argIndex = getNextIndexFor(parentFn.node);
@@ -362,17 +376,13 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           ObjectMethod: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerMethodPath) {
-              if (innerMethodPath.node.kind !== "method") return;
-              const fnExpr = t.functionExpression(
-                null,
-                innerMethodPath.node.params,
-                innerMethodPath.node.body,
-                innerMethodPath.node.generator,
-                innerMethodPath.node.async
-              );
+              if (innerMethodPath.node.kind !== "method")
+                return;
+              const fnExpr = t.functionExpression(null, innerMethodPath.node.params, innerMethodPath.node.body, innerMethodPath.node.generator, innerMethodPath.node.async);
               const deps = Array.from(collectDeps(innerMethodPath));
               const parentFn = innerMethodPath.parentPath?.getFunctionParent() || outerFn;
               const argIndex = getNextIndexFor(parentFn.node);
@@ -402,51 +412,54 @@ function signaliumCallbackTransform(apiOrOpts, opts) {
 }
 const PROMISE_STATIC_METHODS = /* @__PURE__ */ new Set(["all", "race", "any", "allSettled", "resolve", "reject", "withResolvers"]);
 function createSignaliumPromiseMethodsTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["callback", ["signalium"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["callback", ["signalium"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const promiseImportPath = opts?.promiseImportPath ?? "signalium";
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    return importPaths.some(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    return importPaths.some((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
   };
   const isReactiveCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return isTrackedImport(callee.name, path);
   };
   const isWithinTrackedCall = (path) => {
     let current = path.parentPath;
     while (current) {
-      if (current.isCallExpression() && isReactiveCall(current)) return true;
+      if (current.isCallExpression() && isReactiveCall(current))
+        return true;
       current = current.parentPath;
     }
     return false;
   };
   function ensureReactivePromiseIdentifier(programPath) {
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const importDecl2 = bodyPath.node;
-      if (importDecl2.source.value !== promiseImportPath) continue;
+      if (importDecl2.source.value !== promiseImportPath)
+        continue;
       for (const spec of importDecl2.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const ispec = spec;
@@ -458,18 +471,17 @@ function createSignaliumPromiseMethodsTransform(api, opts) {
       }
     }
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const node = bodyPath.node;
-      if (node.source.value !== promiseImportPath) continue;
+      if (node.source.value !== promiseImportPath)
+        continue;
       const localName2 = "ReactivePromise";
       node.specifiers.push(t.importSpecifier(t.identifier(localName2), t.identifier("ReactivePromise")));
       return localName2;
     }
     const localName = "ReactivePromise";
-    const importDecl = t.importDeclaration(
-      [t.importSpecifier(t.identifier(localName), t.identifier("ReactivePromise"))],
-      t.stringLiteral(promiseImportPath)
-    );
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(localName), t.identifier("ReactivePromise"))], t.stringLiteral(promiseImportPath));
     const [first] = programPath.get("body");
     if (first) {
       first.insertBefore(importDecl);
@@ -482,17 +494,24 @@ function createSignaliumPromiseMethodsTransform(api, opts) {
     name: "signalium-transform-reactive-promise-methods",
     visitor: {
       CallExpression(callPath) {
-        if (!isWithinTrackedCall(callPath)) return;
+        if (!isWithinTrackedCall(callPath))
+          return;
         const callee = callPath.node.callee;
-        if (!t.isMemberExpression(callee)) return;
-        if (callee.computed) return;
+        if (!t.isMemberExpression(callee))
+          return;
+        if (callee.computed)
+          return;
         const object = callee.object;
         const property = callee.property;
-        if (!t.isIdentifier(object, { name: "Promise" })) return;
-        if (callPath.scope.getBinding("Promise")) return;
-        if (!t.isIdentifier(property)) return;
+        if (!t.isIdentifier(object, { name: "Promise" }))
+          return;
+        if (callPath.scope.getBinding("Promise"))
+          return;
+        if (!t.isIdentifier(property))
+          return;
         const methodName = property.name;
-        if (!PROMISE_STATIC_METHODS.has(methodName)) return;
+        if (!PROMISE_STATIC_METHODS.has(methodName))
+          return;
         const programPath = callPath.findParent((p) => p.isProgram());
         const reactivePromiseId = ensureReactivePromiseIdentifier(programPath);
         const newCallee = t.memberExpression(t.identifier(reactivePromiseId), t.identifier(methodName));