@zeix/cause-effect 0.17.2 → 0.18.0

package/index.dev.js

@@ -1,162 +1,434 @@
 // src/util.ts
-var isString = (value) => typeof value === "string";
-var isNumber = (value) => typeof value === "number";
-var isSymbol = (value) => typeof value === "symbol";
-var isFunction = (fn) => typeof fn === "function";
-var isAsyncFunction = (fn) => isFunction(fn) && fn.constructor.name === "AsyncFunction";
-var isSyncFunction = (fn) => isFunction(fn) && fn.constructor.name !== "AsyncFunction";
-var isNonNullObject = (value) => value != null && typeof value === "object";
-var isObjectOfType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
-var isRecord = (value) => isObjectOfType(value, "Object");
-var isRecordOrArray = (value) => isRecord(value) || Array.isArray(value);
-var isUniformArray = (value, guard = (item) => item != null) => Array.isArray(value) && value.every(guard);
-var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError";
-var valueString = (value) => isString(value) ? `"${value}"` : !!value && typeof value === "object" ? JSON.stringify(value) : String(value);
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+function isAsyncFunction(fn) {
+  return isFunction(fn) && fn.constructor.name === "AsyncFunction";
+}
+function isSyncFunction(fn) {
+  return isFunction(fn) && fn.constructor.name !== "AsyncFunction";
+}
+function isObjectOfType(value, type) {
+  return Object.prototype.toString.call(value) === `[object ${type}]`;
+}
+function isRecord(value) {
+  return isObjectOfType(value, "Object");
+}
+function isUniformArray(value, guard = (item) => item != null) {
+  return Array.isArray(value) && value.every(guard);
+}
+function valueString(value) {
+  return typeof value === "string" ? `"${value}"` : !!value && typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+
+// src/errors.ts
+class CircularDependencyError extends Error {
+  constructor(where) {
+    super(`[${where}] Circular dependency detected`);
+    this.name = "CircularDependencyError";
+  }
+}
+
+class NullishSignalValueError extends TypeError {
+  constructor(where) {
+    super(`[${where}] Signal value cannot be null or undefined`);
+    this.name = "NullishSignalValueError";
+  }
+}
+
+class UnsetSignalValueError extends Error {
+  constructor(where) {
+    super(`[${where}] Signal value is unset`);
+    this.name = "UnsetSignalValueError";
+  }
+}
+
+class InvalidSignalValueError extends TypeError {
+  constructor(where, value) {
+    super(`[${where}] Signal value ${valueString(value)} is invalid`);
+    this.name = "InvalidSignalValueError";
+  }
+}
+
+class InvalidCallbackError extends TypeError {
+  constructor(where, value) {
+    super(`[${where}] Callback ${valueString(value)} is invalid`);
+    this.name = "InvalidCallbackError";
+  }
+}
+
+class RequiredOwnerError extends Error {
+  constructor(where) {
+    super(`[${where}] Active owner is required`);
+    this.name = "RequiredOwnerError";
+  }
+}
 
-// src/system.ts
-var activeWatcher;
-var unwatchMap = new WeakMap;
-var pendingReactions = new Set;
+class DuplicateKeyError extends Error {
+  constructor(where, key, value) {
+    super(`[${where}] Could not add key "${key}"${value ? ` with value ${JSON.stringify(value)}` : ""} because it already exists`);
+    this.name = "DuplicateKeyError";
+  }
+}
+function validateSignalValue(where, value, guard) {
+  if (value == null)
+    throw new NullishSignalValueError(where);
+  if (guard && !guard(value))
+    throw new InvalidSignalValueError(where, value);
+}
+function validateReadValue(where, value) {
+  if (value == null)
+    throw new UnsetSignalValueError(where);
+}
+function validateCallback(where, value, guard = isFunction) {
+  if (!guard(value))
+    throw new InvalidCallbackError(where, value);
+}
+// src/graph.ts
+var TYPE_STATE = "State";
+var TYPE_MEMO = "Memo";
+var TYPE_TASK = "Task";
+var TYPE_SENSOR = "Sensor";
+var TYPE_LIST = "List";
+var TYPE_COLLECTION = "Collection";
+var TYPE_STORE = "Store";
+var FLAG_CLEAN = 0;
+var FLAG_CHECK = 1 << 0;
+var FLAG_DIRTY = 1 << 1;
+var FLAG_RUNNING = 1 << 2;
+var activeSink = null;
+var activeOwner = null;
+var queuedEffects = [];
 var batchDepth = 0;
-var UNSET = Symbol();
-var HOOK_ADD = "add";
-var HOOK_CHANGE = "change";
-var HOOK_CLEANUP = "cleanup";
-var HOOK_REMOVE = "remove";
-var HOOK_SORT = "sort";
-var HOOK_WATCH = "watch";
-var createWatcher = (react) => {
-  const cleanups = new Set;
-  const watcher = react;
-  watcher.on = (type, cleanup) => {
-    if (type === HOOK_CLEANUP)
-      cleanups.add(cleanup);
-    else
-      throw new InvalidHookError("watcher", type);
-  };
-  watcher.stop = () => {
-    try {
-      for (const cleanup of cleanups)
-        cleanup();
-    } finally {
-      cleanups.clear();
+var flushing = false;
+var DEFAULT_EQUALITY = (a, b) => a === b;
+var SKIP_EQUALITY = (_a, _b) => false;
+function isValidEdge(checkEdge, node) {
+  const sourcesTail = node.sourcesTail;
+  if (sourcesTail) {
+    let edge = node.sources;
+    while (edge) {
+      if (edge === checkEdge)
+        return true;
+      if (edge === sourcesTail)
+        break;
+      edge = edge.nextSource;
     }
-  };
-  return watcher;
-};
-var subscribeActiveWatcher = (watchers, watchHookCallbacks) => {
-  if (!watchers.size && watchHookCallbacks?.size) {
-    const unwatch = triggerHook(watchHookCallbacks);
-    if (unwatch) {
-      const unwatchCallbacks = unwatchMap.get(watchers) ?? new Set;
-      unwatchCallbacks.add(unwatch);
-      if (!unwatchMap.has(watchers))
-        unwatchMap.set(watchers, unwatchCallbacks);
+  }
+  return false;
+}
+function link(source, sink) {
+  const prevSource = sink.sourcesTail;
+  if (prevSource?.source === source)
+    return;
+  let nextSource = null;
+  const isRecomputing = sink.flags & FLAG_RUNNING;
+  if (isRecomputing) {
+    nextSource = prevSource ? prevSource.nextSource : sink.sources;
+    if (nextSource?.source === source) {
+      sink.sourcesTail = nextSource;
+      return;
     }
   }
-  if (activeWatcher && !watchers.has(activeWatcher)) {
-    const watcher = activeWatcher;
-    watcher.on(HOOK_CLEANUP, () => {
-      watchers.delete(watcher);
-      if (!watchers.size) {
-        const unwatchCallbacks = unwatchMap.get(watchers);
-        if (unwatchCallbacks) {
-          try {
-            for (const unwatch of unwatchCallbacks)
-              unwatch();
-          } finally {
-            unwatchCallbacks.clear();
-            unwatchMap.delete(watchers);
-          }
-        }
-      }
-    });
-    watchers.add(watcher);
+  const prevSink = source.sinksTail;
+  if (prevSink?.sink === sink && (!isRecomputing || isValidEdge(prevSink, sink)))
+    return;
+  const newEdge = { source, sink, nextSource, prevSink, nextSink: null };
+  sink.sourcesTail = source.sinksTail = newEdge;
+  if (prevSource)
+    prevSource.nextSource = newEdge;
+  else
+    sink.sources = newEdge;
+  if (prevSink)
+    prevSink.nextSink = newEdge;
+  else
+    source.sinks = newEdge;
+}
+function unlink(edge) {
+  const { source, nextSource, nextSink, prevSink } = edge;
+  if (nextSink)
+    nextSink.prevSink = prevSink;
+  else
+    source.sinksTail = prevSink;
+  if (prevSink)
+    prevSink.nextSink = nextSink;
+  else
+    source.sinks = nextSink;
+  if (!source.sinks && source.stop) {
+    source.stop();
+    source.stop = undefined;
+  }
+  return nextSource;
+}
+function trimSources(node) {
+  const tail = node.sourcesTail;
+  let source = tail ? tail.nextSource : node.sources;
+  while (source)
+    source = unlink(source);
+  if (tail)
+    tail.nextSource = null;
+  else
+    node.sources = null;
+}
+function propagate(node, newFlag = FLAG_DIRTY) {
+  const flags = node.flags;
+  if ("sinks" in node) {
+    if ((flags & (FLAG_DIRTY | FLAG_CHECK)) >= newFlag)
+      return;
+    node.flags = flags | newFlag;
+    if ("controller" in node && node.controller) {
+      node.controller.abort();
+      node.controller = undefined;
+    }
+    for (let e = node.sinks;e; e = e.nextSink)
+      propagate(e.sink, FLAG_CHECK);
+  } else {
+    if (flags & FLAG_DIRTY)
+      return;
+    node.flags = FLAG_DIRTY;
+    queuedEffects.push(node);
   }
-};
-var notifyWatchers = (watchers) => {
-  if (!watchers.size)
-    return false;
-  for (const react of watchers) {
-    if (batchDepth)
-      pendingReactions.add(react);
+}
+function setState(node, next) {
+  if (node.equals(node.value, next))
+    return;
+  node.value = next;
+  for (let e = node.sinks;e; e = e.nextSink)
+    propagate(e.sink);
+  if (batchDepth === 0)
+    flush();
+}
+function registerCleanup(owner, fn) {
+  if (!owner.cleanup)
+    owner.cleanup = fn;
+  else if (Array.isArray(owner.cleanup))
+    owner.cleanup.push(fn);
+  else
+    owner.cleanup = [owner.cleanup, fn];
+}
+function runCleanup(owner) {
+  if (!owner.cleanup)
+    return;
+  if (Array.isArray(owner.cleanup))
+    for (let i = 0;i < owner.cleanup.length; i++)
+      owner.cleanup[i]();
+  else
+    owner.cleanup();
+  owner.cleanup = null;
+}
+function recomputeMemo(node) {
+  const prevWatcher = activeSink;
+  activeSink = node;
+  node.sourcesTail = null;
+  node.flags = FLAG_RUNNING;
+  let changed = false;
+  try {
+    const next = node.fn(node.value);
+    if (node.error || !node.equals(next, node.value)) {
+      node.value = next;
+      node.error = undefined;
+      changed = true;
+    }
+  } catch (err) {
+    changed = true;
+    node.error = err instanceof Error ? err : new Error(String(err));
+  } finally {
+    activeSink = prevWatcher;
+    trimSources(node);
+  }
+  if (changed) {
+    for (let e = node.sinks;e; e = e.nextSink)
+      if (e.sink.flags & FLAG_CHECK)
+        e.sink.flags |= FLAG_DIRTY;
+  }
+  node.flags = FLAG_CLEAN;
+}
+function recomputeTask(node) {
+  node.controller?.abort();
+  const controller = new AbortController;
+  node.controller = controller;
+  node.error = undefined;
+  const prevWatcher = activeSink;
+  activeSink = node;
+  node.sourcesTail = null;
+  node.flags = FLAG_RUNNING;
+  let promise;
+  try {
+    promise = node.fn(node.value, controller.signal);
+  } catch (err) {
+    node.controller = undefined;
+    node.error = err instanceof Error ? err : new Error(String(err));
+    return;
+  } finally {
+    activeSink = prevWatcher;
+    trimSources(node);
+  }
+  promise.then((next) => {
+    if (controller.signal.aborted)
+      return;
+    node.controller = undefined;
+    if (node.error || !node.equals(next, node.value)) {
+      node.value = next;
+      node.error = undefined;
+      for (let e = node.sinks;e; e = e.nextSink)
+        propagate(e.sink);
+      if (batchDepth === 0)
+        flush();
+    }
+  }, (err) => {
+    if (controller.signal.aborted)
+      return;
+    node.controller = undefined;
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (!node.error || error.name !== node.error.name || error.message !== node.error.message) {
+      node.error = error;
+      for (let e = node.sinks;e; e = e.nextSink)
+        propagate(e.sink);
+      if (batchDepth === 0)
+        flush();
+    }
+  });
+  node.flags = FLAG_CLEAN;
+}
+function runEffect(node) {
+  runCleanup(node);
+  const prevContext = activeSink;
+  const prevOwner = activeOwner;
+  activeSink = activeOwner = node;
+  node.sourcesTail = null;
+  node.flags = FLAG_RUNNING;
+  try {
+    const out = node.fn();
+    if (typeof out === "function")
+      registerCleanup(node, out);
+  } finally {
+    activeSink = prevContext;
+    activeOwner = prevOwner;
+    trimSources(node);
+  }
+  node.flags = FLAG_CLEAN;
+}
+function refresh(node) {
+  if (node.flags & FLAG_CHECK) {
+    for (let e = node.sources;e; e = e.nextSource) {
+      if ("fn" in e.source)
+        refresh(e.source);
+      if (node.flags & FLAG_DIRTY)
+        break;
+    }
+  }
+  if (node.flags & FLAG_RUNNING) {
+    throw new CircularDependencyError("controller" in node ? TYPE_TASK : ("value" in node) ? TYPE_MEMO : "Effect");
+  }
+  if (node.flags & FLAG_DIRTY) {
+    if ("controller" in node)
+      recomputeTask(node);
+    else if ("value" in node)
+      recomputeMemo(node);
     else
-      react();
+      runEffect(node);
+  } else {
+    node.flags = FLAG_CLEAN;
   }
-  return true;
-};
-var flushPendingReactions = () => {
-  while (pendingReactions.size) {
-    const watchers = Array.from(pendingReactions);
-    pendingReactions.clear();
-    for (const watcher of watchers)
-      watcher();
+}
+function flush() {
+  if (flushing)
+    return;
+  flushing = true;
+  try {
+    for (let i = 0;i < queuedEffects.length; i++) {
+      const effect = queuedEffects[i];
+      if (effect.flags & FLAG_DIRTY)
+        refresh(effect);
+    }
+    queuedEffects.length = 0;
+  } finally {
+    flushing = false;
   }
-};
-var batchSignalWrites = (callback) => {
+}
+function batch(fn) {
   batchDepth++;
   try {
-    callback();
+    fn();
   } finally {
-    flushPendingReactions();
     batchDepth--;
+    if (batchDepth === 0)
+      flush();
   }
-};
-var trackSignalReads = (watcher, run) => {
-  const prev = activeWatcher;
-  activeWatcher = watcher || undefined;
+}
+function untrack(fn) {
+  const prev = activeSink;
+  activeSink = null;
   try {
-    run();
+    return fn();
   } finally {
-    activeWatcher = prev;
+    activeSink = prev;
   }
-};
-var triggerHook = (callbacks, payload) => {
-  if (!callbacks)
-    return;
-  const cleanups = [];
-  const errors = [];
-  const throwError = (inCleanup) => {
-    if (errors.length) {
-      if (errors.length === 1)
-        throw errors[0];
-      throw new AggregateError(errors, `Errors in hook ${inCleanup ? "cleanup" : "callback"}:`);
-    }
-  };
-  for (const callback of callbacks) {
-    try {
-      const cleanup = callback(payload);
-      if (isFunction(cleanup))
-        cleanups.push(cleanup);
-    } catch (error) {
-      errors.push(createError(error));
-    }
+}
+function createScope(fn) {
+  const prevOwner = activeOwner;
+  const scope = { cleanup: null };
+  activeOwner = scope;
+  try {
+    const out = fn();
+    if (typeof out === "function")
+      registerCleanup(scope, out);
+    const dispose = () => runCleanup(scope);
+    if (prevOwner)
+      registerCleanup(prevOwner, dispose);
+    return dispose;
+  } finally {
+    activeOwner = prevOwner;
   }
-  throwError();
-  if (!cleanups.length)
-    return;
-  if (cleanups.length === 1)
-    return cleanups[0];
-  return () => {
-    for (const cleanup of cleanups) {
-      try {
-        cleanup();
-      } catch (error) {
-        errors.push(createError(error));
-      }
+}
+// src/nodes/state.ts
+function createState(value, options) {
+  validateSignalValue(TYPE_STATE, value, options?.guard);
+  const node = {
+    value,
+    sinks: null,
+    sinksTail: null,
+    equals: options?.equals ?? DEFAULT_EQUALITY,
+    guard: options?.guard
+  };
+  return {
+    [Symbol.toStringTag]: TYPE_STATE,
+    get() {
+      if (activeSink)
+        link(node, activeSink);
+      return node.value;
+    },
+    set(next) {
+      validateSignalValue(TYPE_STATE, next, node.guard);
+      setState(node, next);
+    },
+    update(fn) {
+      validateCallback(TYPE_STATE, fn);
+      const next = fn(node.value);
+      validateSignalValue(TYPE_STATE, next, node.guard);
+      setState(node, next);
     }
-    throwError(true);
   };
-};
-var isHandledHook = (type, handled) => handled.includes(type);
+}
+function isState(value) {
+  return isObjectOfType(value, TYPE_STATE);
+}
 
-// src/diff.ts
-var isEqual = (a, b, visited) => {
+// src/nodes/list.ts
+function keysEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+}
+function isEqual(a, b, visited) {
   if (Object.is(a, b))
     return true;
   if (typeof a !== typeof b)
     return false;
-  if (!isNonNullObject(a) || !isNonNullObject(b))
+  if (a == null || typeof a !== "object" || b == null || typeof b !== "object")
     return false;
   if (!visited)
     visited = new WeakSet;
@@ -165,17 +437,20 @@ var isEqual = (a, b, visited) => {
   visited.add(a);
   visited.add(b);
   try {
-    if (Array.isArray(a) && Array.isArray(b)) {
-      if (a.length !== b.length)
+    const aIsArray = Array.isArray(a);
+    if (aIsArray !== Array.isArray(b))
+      return false;
+    if (aIsArray) {
+      const aa = a;
+      const ba = b;
+      if (aa.length !== ba.length)
         return false;
-      for (let i = 0;i < a.length; i++) {
-        if (!isEqual(a[i], b[i], visited))
+      for (let i = 0;i < aa.length; i++) {
+        if (!isEqual(aa[i], ba[i], visited))
           return false;
       }
       return true;
     }
-    if (Array.isArray(a) !== Array.isArray(b))
-      return false;
     if (isRecord(a) && isRecord(b)) {
       const aKeys = Object.keys(a);
       const bKeys = Object.keys(b);
@@ -194,679 +469,913 @@ var isEqual = (a, b, visited) => {
     visited.delete(a);
     visited.delete(b);
   }
-};
-var diff = (oldObj, newObj) => {
-  const oldValid = isRecordOrArray(oldObj);
-  const newValid = isRecordOrArray(newObj);
-  if (!oldValid || !newValid) {
-    const changed = !Object.is(oldObj, newObj);
-    return {
-      changed,
-      add: changed && newValid ? newObj : {},
-      change: {},
-      remove: changed && oldValid ? oldObj : {}
-    };
-  }
+}
+function diffArrays(oldArray, newArray, currentKeys, generateKey, contentBased) {
   const visited = new WeakSet;
   const add = {};
   const change = {};
   const remove = {};
-  const oldKeys = Object.keys(oldObj);
-  const newKeys = Object.keys(newObj);
-  const allKeys = new Set([...oldKeys, ...newKeys]);
-  for (const key of allKeys) {
-    const oldHas = key in oldObj;
-    const newHas = key in newObj;
-    if (!oldHas && newHas) {
-      add[key] = newObj[key];
-      continue;
-    } else if (oldHas && !newHas) {
-      remove[key] = UNSET;
+  const newKeys = [];
+  let changed = false;
+  const oldByKey = new Map;
+  for (let i = 0;i < oldArray.length; i++) {
+    const key = currentKeys[i];
+    if (key && oldArray[i])
+      oldByKey.set(key, oldArray[i]);
+  }
+  const seenKeys = new Set;
+  for (let i = 0;i < newArray.length; i++) {
+    const newValue = newArray[i];
+    if (newValue === undefined)
       continue;
+    const key = contentBased ? generateKey(newValue) : currentKeys[i] ?? generateKey(newValue);
+    if (seenKeys.has(key))
+      throw new DuplicateKeyError(TYPE_LIST, key, newValue);
+    newKeys.push(key);
+    seenKeys.add(key);
+    if (!oldByKey.has(key)) {
+      add[key] = newValue;
+      changed = true;
+    } else {
+      const oldValue = oldByKey.get(key);
+      if (!isEqual(oldValue, newValue, visited)) {
+        change[key] = newValue;
+        changed = true;
+      }
     }
-    const oldValue = oldObj[key];
-    const newValue = newObj[key];
-    if (!isEqual(oldValue, newValue, visited))
-      change[key] = newValue;
-  }
-  return {
-    add,
-    change,
-    remove,
-    changed: !!(Object.keys(add).length || Object.keys(change).length || Object.keys(remove).length)
-  };
-};
-
-// src/classes/computed.ts
-var TYPE_COMPUTED = "Computed";
-
-class Memo {
-  #watchers = new Set;
-  #callback;
-  #value;
-  #error;
-  #dirty = true;
-  #computing = false;
-  #watcher;
-  #watchHookCallbacks;
-  constructor(callback, initialValue = UNSET) {
-    validateCallback(this.constructor.name, callback, isMemoCallback);
-    validateSignalValue(this.constructor.name, initialValue);
-    this.#callback = callback;
-    this.#value = initialValue;
-  }
-  #getWatcher() {
-    if (!this.#watcher) {
-      this.#watcher = createWatcher(() => {
-        this.#dirty = true;
-        if (!notifyWatchers(this.#watchers))
-          this.#watcher?.stop();
-      });
-      this.#watcher.on(HOOK_CLEANUP, () => {
-        this.#watcher = undefined;
-      });
-    }
-    return this.#watcher;
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_COMPUTED;
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks);
-    flushPendingReactions();
-    if (this.#dirty) {
-      const watcher = this.#getWatcher();
-      trackSignalReads(watcher, () => {
-        if (this.#computing)
-          throw new CircularDependencyError("memo");
-        let result;
-        this.#computing = true;
-        try {
-          result = this.#callback(this.#value);
-        } catch (e) {
-          this.#value = UNSET;
-          this.#error = createError(e);
-          this.#computing = false;
-          return;
-        }
-        if (result == null || UNSET === result) {
-          this.#value = UNSET;
-          this.#error = undefined;
-        } else {
-          this.#value = result;
-          this.#error = undefined;
-          this.#dirty = false;
-        }
-        this.#computing = false;
-      });
-    }
-    if (this.#error)
-      throw this.#error;
-    return this.#value;
   }
-  on(type, callback) {
-    if (type === HOOK_WATCH) {
-      this.#watchHookCallbacks ||= new Set;
-      this.#watchHookCallbacks.add(callback);
-      return () => {
-        this.#watchHookCallbacks?.delete(callback);
-      };
+  for (const [key] of oldByKey) {
+    if (!seenKeys.has(key)) {
+      remove[key] = null;
+      changed = true;
     }
-    throw new InvalidHookError(this.constructor.name, type);
   }
+  if (!changed && !keysEqual(currentKeys, newKeys))
+    changed = true;
+  return { add, change, remove, newKeys, changed };
 }
-
-class Task {
-  #watchers = new Set;
-  #callback;
-  #value;
-  #error;
-  #dirty = true;
-  #computing = false;
-  #changed = false;
-  #watcher;
-  #controller;
-  #watchHookCallbacks;
-  constructor(callback, initialValue = UNSET) {
-    validateCallback(this.constructor.name, callback, isTaskCallback);
-    validateSignalValue(this.constructor.name, initialValue);
-    this.#callback = callback;
-    this.#value = initialValue;
-  }
-  #getWatcher() {
-    if (!this.#watcher) {
-      this.#watcher = createWatcher(() => {
-        this.#dirty = true;
-        this.#controller?.abort();
-        if (!notifyWatchers(this.#watchers))
-          this.#watcher?.stop();
-      });
-      this.#watcher.on(HOOK_CLEANUP, () => {
-        this.#controller?.abort();
-        this.#controller = undefined;
-        this.#watcher = undefined;
-      });
-    }
-    return this.#watcher;
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_COMPUTED;
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks);
-    flushPendingReactions();
-    const ok = (v) => {
-      if (!isEqual(v, this.#value)) {
-        this.#value = v;
-        this.#changed = true;
-      }
-      this.#error = undefined;
-      this.#dirty = false;
-    };
-    const nil = () => {
-      this.#changed = UNSET !== this.#value;
-      this.#value = UNSET;
-      this.#error = undefined;
-    };
-    const err = (e) => {
-      const newError = createError(e);
-      this.#changed = !this.#error || newError.name !== this.#error.name || newError.message !== this.#error.message;
-      this.#value = UNSET;
-      this.#error = newError;
-    };
-    const settle = (fn) => (arg) => {
-      this.#computing = false;
-      this.#controller = undefined;
-      fn(arg);
-      if (this.#changed && !notifyWatchers(this.#watchers))
-        this.#watcher?.stop();
-    };
-    const compute = () => trackSignalReads(this.#getWatcher(), () => {
-      if (this.#computing)
-        throw new CircularDependencyError("task");
-      this.#changed = false;
-      if (this.#controller)
-        return this.#value;
-      this.#controller = new AbortController;
-      this.#controller.signal.addEventListener("abort", () => {
-        this.#computing = false;
-        this.#controller = undefined;
-        compute();
-      }, {
-        once: true
-      });
-      let result;
-      this.#computing = true;
-      try {
-        result = this.#callback(this.#value, this.#controller.signal);
-      } catch (e) {
-        if (isAbortError(e))
-          nil();
-        else
-          err(e);
-        this.#computing = false;
-        return;
+function createList(initialValue, options) {
+  validateSignalValue(TYPE_LIST, initialValue, Array.isArray);
+  const signals = new Map;
+  let keys = [];
+  let keyCounter = 0;
+  const keyConfig = options?.keyConfig;
+  const contentBased = isFunction(keyConfig);
+  const generateKey = typeof keyConfig === "string" ? () => `${keyConfig}${keyCounter++}` : contentBased ? (item) => keyConfig(item) : () => String(keyCounter++);
+  const buildValue = () => keys.map((key) => signals.get(key)?.get()).filter((v) => v !== undefined);
+  const node = {
+    fn: buildValue,
+    value: initialValue,
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    equals: isEqual,
+    error: undefined
+  };
+  const toRecord = (array) => {
+    const record = {};
+    for (let i = 0;i < array.length; i++) {
+      const value = array[i];
+      if (value === undefined)
+        continue;
+      let key = keys[i];
+      if (!key) {
+        key = generateKey(value);
+        keys[i] = key;
       }
-      if (result instanceof Promise)
-        result.then(settle(ok), settle(err));
-      else if (result == null || UNSET === result)
-        nil();
-      else
-        ok(result);
-      this.#computing = false;
-    });
-    if (this.#dirty)
-      compute();
-    if (this.#error)
-      throw this.#error;
-    return this.#value;
-  }
-  on(type, callback) {
-    if (type === HOOK_WATCH) {
-      this.#watchHookCallbacks ||= new Set;
-      this.#watchHookCallbacks.add(callback);
-      return () => {
-        this.#watchHookCallbacks?.delete(callback);
-      };
-    }
-    throw new InvalidHookError(this.constructor.name, type);
-  }
-}
-var createComputed = (callback, initialValue = UNSET) => isAsyncFunction(callback) ? new Task(callback, initialValue) : new Memo(callback, initialValue);
-var isComputed = (value) => isObjectOfType(value, TYPE_COMPUTED);
-var isMemoCallback = (value) => isSyncFunction(value) && value.length < 2;
-var isTaskCallback = (value) => isAsyncFunction(value) && value.length < 3;
-
-// src/classes/composite.ts
-class Composite {
-  signals = new Map;
-  #validate;
-  #create;
-  #watchers = new Map;
-  #hookCallbacks = {};
-  #batching = false;
-  constructor(values, validate, create) {
-    this.#validate = validate;
-    this.#create = create;
-    this.change({
-      add: values,
-      change: {},
-      remove: {},
-      changed: true
-    }, true);
-  }
-  #addWatcher(key) {
-    const watcher = createWatcher(() => {
-      trackSignalReads(watcher, () => {
-        this.signals.get(key)?.get();
-        if (!this.#batching)
-          triggerHook(this.#hookCallbacks.change, [key]);
-      });
-    });
-    this.#watchers.set(key, watcher);
-    watcher();
-  }
-  add(key, value) {
-    if (!this.#validate(key, value))
-      return false;
-    this.signals.set(key, this.#create(value));
-    if (this.#hookCallbacks.change?.size)
-      this.#addWatcher(key);
-    if (!this.#batching)
-      triggerHook(this.#hookCallbacks.add, [key]);
-    return true;
-  }
-  remove(key) {
-    const ok = this.signals.delete(key);
-    if (!ok)
-      return false;
-    const watcher = this.#watchers.get(key);
-    if (watcher) {
-      watcher.stop();
-      this.#watchers.delete(key);
+      record[key] = value;
     }
-    if (!this.#batching)
-      triggerHook(this.#hookCallbacks.remove, [key]);
-    return true;
-  }
-  change(changes, initialRun) {
-    this.#batching = true;
-    if (Object.keys(changes.add).length) {
-      for (const key in changes.add)
-        this.add(key, changes.add[key]);
-      const notify = () => triggerHook(this.#hookCallbacks.add, Object.keys(changes.add));
-      if (initialRun)
-        setTimeout(notify, 0);
-      else
-        notify();
+    return record;
+  };
+  const applyChanges = (changes) => {
+    let structural = false;
+    for (const key in changes.add) {
+      const value = changes.add[key];
+      validateSignalValue(`${TYPE_LIST} item for key "${key}"`, value);
+      signals.set(key, createState(value));
+      structural = true;
     }
     if (Object.keys(changes.change).length) {
-      batchSignalWrites(() => {
+      batch(() => {
         for (const key in changes.change) {
           const value = changes.change[key];
-          if (!this.#validate(key, value))
-            continue;
-          const signal = this.signals.get(key);
-          if (guardMutableSignal(`list item "${key}"`, value, signal))
+          validateSignalValue(`${TYPE_LIST} item for key "${key}"`, value);
+          const signal = signals.get(key);
+          if (signal)
             signal.set(value);
         }
       });
-      triggerHook(this.#hookCallbacks.change, Object.keys(changes.change));
     }
-    if (Object.keys(changes.remove).length) {
-      for (const key in changes.remove)
-        this.remove(key);
-      triggerHook(this.#hookCallbacks.remove, Object.keys(changes.remove));
+    for (const key in changes.remove) {
+      signals.delete(key);
+      const index = keys.indexOf(key);
+      if (index !== -1)
+        keys.splice(index, 1);
+      structural = true;
     }
-    this.#batching = false;
-    return changes.changed;
-  }
-  clear() {
-    const keys = Array.from(this.signals.keys());
-    this.signals.clear();
-    this.#watchers.clear();
-    triggerHook(this.#hookCallbacks.remove, keys);
-    return true;
-  }
-  on(type, callback) {
-    if (!isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE]))
-      throw new InvalidHookError("Composite", type);
-    this.#hookCallbacks[type] ||= new Set;
-    this.#hookCallbacks[type].add(callback);
-    if (type === HOOK_CHANGE && !this.#watchers.size) {
-      this.#batching = true;
-      for (const key of this.signals.keys())
-        this.#addWatcher(key);
-      this.#batching = false;
+    if (structural) {
+      node.sources = null;
+      node.sourcesTail = null;
     }
-    return () => {
-      this.#hookCallbacks[type]?.delete(callback);
-      if (type === HOOK_CHANGE && !this.#hookCallbacks.change?.size) {
-        if (this.#watchers.size) {
-          for (const watcher of this.#watchers.values())
-            watcher.stop();
-          this.#watchers.clear();
-        }
+    return changes.changed;
+  };
+  const initRecord = toRecord(initialValue);
+  for (const key in initRecord) {
+    const value = initRecord[key];
+    validateSignalValue(`${TYPE_LIST} item for key "${key}"`, value);
+    signals.set(key, createState(value));
+  }
+  node.value = initialValue;
+  node.flags = 0;
+  const list = {
+    [Symbol.toStringTag]: TYPE_LIST,
+    [Symbol.isConcatSpreadable]: true,
+    *[Symbol.iterator]() {
+      for (const key of keys) {
+        const signal = signals.get(key);
+        if (signal)
+          yield signal;
       }
-    };
-  }
-}
-
-// src/classes/state.ts
-var TYPE_STATE = "State";
-
-class State {
-  #watchers = new Set;
-  #value;
-  #watchHookCallbacks;
-  constructor(initialValue) {
-    validateSignalValue(TYPE_STATE, initialValue);
-    this.#value = initialValue;
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_STATE;
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks);
-    return this.#value;
-  }
-  set(newValue) {
-    validateSignalValue(TYPE_STATE, newValue);
-    if (isEqual(this.#value, newValue))
-      return;
-    this.#value = newValue;
-    if (this.#watchers.size)
-      notifyWatchers(this.#watchers);
-    if (UNSET === this.#value)
-      this.#watchers.clear();
-  }
-  update(updater) {
-    validateCallback(`${TYPE_STATE} update`, updater);
-    this.set(updater(this.#value));
-  }
-  on(type, callback) {
-    if (type === HOOK_WATCH) {
-      this.#watchHookCallbacks ||= new Set;
-      this.#watchHookCallbacks.add(callback);
-      return () => {
-        this.#watchHookCallbacks?.delete(callback);
-      };
-    }
-    throw new InvalidHookError(this.constructor.name, type);
-  }
-}
-var isState = (value) => isObjectOfType(value, TYPE_STATE);
-
-// src/classes/list.ts
-var TYPE_LIST = "List";
-
-class List {
-  #composite;
-  #watchers = new Set;
-  #hookCallbacks = {};
-  #order = [];
-  #generateKey;
-  constructor(initialValue, keyConfig) {
-    validateSignalValue(TYPE_LIST, initialValue, Array.isArray);
-    let keyCounter = 0;
-    this.#generateKey = isString(keyConfig) ? () => `${keyConfig}${keyCounter++}` : isFunction(keyConfig) ? (item) => keyConfig(item) : () => String(keyCounter++);
-    this.#composite = new Composite(this.#toRecord(initialValue), (key, value) => {
-      validateSignalValue(`${TYPE_LIST} for key "${key}"`, value);
-      return true;
-    }, (value) => new State(value));
-  }
-  #toRecord(array) {
-    const record = {};
-    for (let i = 0;i < array.length; i++) {
-      const value = array[i];
-      if (value === undefined)
-        continue;
-      let key = this.#order[i];
-      if (!key) {
-        key = this.#generateKey(value);
-        this.#order[i] = key;
+    },
+    get length() {
+      if (activeSink) {
+        if (!node.sinks && options?.watched)
+          node.stop = options.watched();
+        link(node, activeSink);
       }
-      record[key] = value;
+      return keys.length;
+    },
+    get() {
+      if (activeSink) {
+        if (!node.sinks && options?.watched)
+          node.stop = options.watched();
+        link(node, activeSink);
+      }
+      if (node.sources) {
+        if (node.flags) {
+          node.value = untrack(buildValue);
+          node.flags = FLAG_CLEAN;
+        }
+      } else {
+        refresh(node);
+        if (node.error)
+          throw node.error;
+      }
+      return node.value;
+    },
+    set(newValue) {
+      const currentValue = node.flags & FLAG_DIRTY ? buildValue() : node.value;
+      const changes = diffArrays(currentValue, newValue, keys, generateKey, contentBased);
+      if (changes.changed) {
+        keys = changes.newKeys;
+        applyChanges(changes);
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+    },
+    update(fn) {
+      list.set(fn(list.get()));
+    },
+    at(index) {
+      return signals.get(keys[index]);
+    },
+    keys() {
+      if (activeSink) {
+        if (!node.sinks && options?.watched)
+          node.stop = options.watched();
+        link(node, activeSink);
+      }
+      return keys.values();
+    },
+    byKey(key) {
+      return signals.get(key);
+    },
+    keyAt(index) {
+      return keys[index];
+    },
+    indexOfKey(key) {
+      return keys.indexOf(key);
+    },
+    add(value) {
+      const key = generateKey(value);
+      if (signals.has(key))
+        throw new DuplicateKeyError(TYPE_LIST, key, value);
+      if (!keys.includes(key))
+        keys.push(key);
+      validateSignalValue(`${TYPE_LIST} item for key "${key}"`, value);
+      signals.set(key, createState(value));
+      node.sources = null;
+      node.sourcesTail = null;
+      propagate(node);
+      node.flags |= FLAG_DIRTY;
+      if (batchDepth === 0)
+        flush();
+      return key;
+    },
+    remove(keyOrIndex) {
+      const key = typeof keyOrIndex === "number" ? keys[keyOrIndex] : keyOrIndex;
+      const ok = signals.delete(key);
+      if (ok) {
+        const index = typeof keyOrIndex === "number" ? keyOrIndex : keys.indexOf(key);
+        if (index >= 0)
+          keys.splice(index, 1);
+        node.sources = null;
+        node.sourcesTail = null;
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+    },
+    sort(compareFn) {
+      const entries = keys.map((key) => [key, signals.get(key)?.get()]).sort(isFunction(compareFn) ? (a, b) => compareFn(a[1], b[1]) : (a, b) => String(a[1]).localeCompare(String(b[1])));
+      const newOrder = entries.map(([key]) => key);
+      if (!keysEqual(keys, newOrder)) {
+        keys = newOrder;
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+    },
+    splice(start, deleteCount, ...items) {
+      const length = keys.length;
+      const actualStart = start < 0 ? Math.max(0, length + start) : Math.min(start, length);
+      const actualDeleteCount = Math.max(0, Math.min(deleteCount ?? Math.max(0, length - Math.max(0, actualStart)), length - actualStart));
+      const add = {};
+      const remove = {};
+      for (let i = 0;i < actualDeleteCount; i++) {
+        const index = actualStart + i;
+        const key = keys[index];
+        if (key) {
+          const signal = signals.get(key);
+          if (signal)
+            remove[key] = signal.get();
+        }
+      }
+      const newOrder = keys.slice(0, actualStart);
+      for (const item of items) {
+        const key = generateKey(item);
+        if (signals.has(key) && !(key in remove))
+          throw new DuplicateKeyError(TYPE_LIST, key, item);
+        newOrder.push(key);
+        add[key] = item;
+      }
+      newOrder.push(...keys.slice(actualStart + actualDeleteCount));
+      const changed = !!(Object.keys(add).length || Object.keys(remove).length);
+      if (changed) {
+        applyChanges({
+          add,
+          change: {},
+          remove,
+          changed
+        });
+        keys = newOrder;
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+      return Object.values(remove);
+    },
+    deriveCollection(cb) {
+      return deriveCollection(list, cb);
     }
-    return record;
-  }
-  get #value() {
-    return this.#order.map((key) => this.#composite.signals.get(key)?.get()).filter((v) => v !== undefined);
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_LIST;
-  }
-  get [Symbol.isConcatSpreadable]() {
-    return true;
-  }
-  *[Symbol.iterator]() {
-    for (const key of this.#order) {
-      const signal = this.#composite.signals.get(key);
-      if (signal)
-        yield signal;
+  };
+  return list;
+}
+function isList(value) {
+  return isObjectOfType(value, TYPE_LIST);
+}
+
+// src/nodes/memo.ts
+function createMemo(fn, options) {
+  validateCallback(TYPE_MEMO, fn, isSyncFunction);
+  if (options?.value !== undefined)
+    validateSignalValue(TYPE_MEMO, options.value, options?.guard);
+  const node = {
+    fn,
+    value: options?.value,
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    equals: options?.equals ?? DEFAULT_EQUALITY,
+    error: undefined
+  };
+  return {
+    [Symbol.toStringTag]: TYPE_MEMO,
+    get() {
+      if (activeSink)
+        link(node, activeSink);
+      refresh(node);
+      if (node.error)
+        throw node.error;
+      validateReadValue(TYPE_MEMO, node.value);
+      return node.value;
     }
-  }
-  get length() {
-    subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH]);
-    return this.#order.length;
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH]);
-    return this.#value;
-  }
-  set(newValue) {
-    if (UNSET === newValue) {
-      this.#composite.clear();
-      notifyWatchers(this.#watchers);
-      this.#watchers.clear();
-      return;
+  };
+}
+function isMemo(value) {
+  return isObjectOfType(value, TYPE_MEMO);
+}
+
+// src/nodes/task.ts
+function createTask(fn, options) {
+  validateCallback(TYPE_TASK, fn, isAsyncFunction);
+  if (options?.value !== undefined)
+    validateSignalValue(TYPE_TASK, options.value, options?.guard);
+  const node = {
+    fn,
+    value: options?.value,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    flags: FLAG_DIRTY,
+    equals: options?.equals ?? DEFAULT_EQUALITY,
+    controller: undefined,
+    error: undefined
+  };
+  return {
+    [Symbol.toStringTag]: TYPE_TASK,
+    get() {
+      if (activeSink)
+        link(node, activeSink);
+      refresh(node);
+      if (node.error)
+        throw node.error;
+      validateReadValue(TYPE_TASK, node.value);
+      return node.value;
+    },
+    isPending() {
+      return !!node.controller;
+    },
+    abort() {
+      node.controller?.abort();
+      node.controller = undefined;
     }
-    const oldValue = this.#value;
-    const changes = diff(this.#toRecord(oldValue), this.#toRecord(newValue));
-    const removedKeys = Object.keys(changes.remove);
-    const changed = this.#composite.change(changes);
-    if (changed) {
-      for (const key of removedKeys) {
-        const index = this.#order.indexOf(key);
-        if (index !== -1)
-          this.#order.splice(index, 1);
+  };
+}
+function isTask(value) {
+  return isObjectOfType(value, TYPE_TASK);
+}
+
+// src/nodes/collection.ts
+function deriveCollection(source, callback) {
+  validateCallback(TYPE_COLLECTION, callback);
+  if (!isCollectionSource(source))
+    throw new TypeError(`[${TYPE_COLLECTION}] Invalid collection source: expected a List or Collection`);
+  const isAsync = isAsyncFunction(callback);
+  const signals = new Map;
+  const addSignal = (key) => {
+    const signal = isAsync ? createTask(async (prev, abort) => {
+      const sourceValue = source.byKey(key)?.get();
+      if (sourceValue == null)
+        return prev;
+      return callback(sourceValue, abort);
+    }) : createMemo(() => {
+      const sourceValue = source.byKey(key)?.get();
+      if (sourceValue == null)
+        return;
+      return callback(sourceValue);
+    });
+    signals.set(key, signal);
+  };
+  function syncKeys() {
+    const newKeys = Array.from(source.keys());
+    const oldKeys = node.value;
+    if (!keysEqual(oldKeys, newKeys)) {
+      const oldKeySet = new Set(oldKeys);
+      const newKeySet = new Set(newKeys);
+      for (const key of oldKeys)
+        if (!newKeySet.has(key))
+          signals.delete(key);
+      for (const key of newKeys)
+        if (!oldKeySet.has(key))
+          addSignal(key);
+    }
+    return newKeys;
+  }
+  const node = {
+    fn: syncKeys,
+    value: [],
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    equals: keysEqual,
+    error: undefined
+  };
+  function ensureSynced() {
+    if (node.sources) {
+      if (node.flags) {
+        node.value = untrack(syncKeys);
+        node.flags = FLAG_CLEAN;
       }
-      this.#order = this.#order.filter(() => true);
-      notifyWatchers(this.#watchers);
+    } else {
+      refresh(node);
+      if (node.error)
+        throw node.error;
     }
-  }
-  update(fn) {
-    this.set(fn(this.get()));
-  }
-  at(index) {
-    return this.#composite.signals.get(this.#order[index]);
-  }
-  keys() {
-    return this.#order.values();
-  }
-  byKey(key) {
-    return this.#composite.signals.get(key);
-  }
-  keyAt(index) {
-    return this.#order[index];
-  }
-  indexOfKey(key) {
-    return this.#order.indexOf(key);
-  }
-  add(value) {
-    const key = this.#generateKey(value);
-    if (this.#composite.signals.has(key))
-      throw new DuplicateKeyError("store", key, value);
-    if (!this.#order.includes(key))
-      this.#order.push(key);
-    const ok = this.#composite.add(key, value);
-    if (ok)
-      notifyWatchers(this.#watchers);
-    return key;
-  }
-  remove(keyOrIndex) {
-    const key = isNumber(keyOrIndex) ? this.#order[keyOrIndex] : keyOrIndex;
-    const ok = this.#composite.remove(key);
-    if (ok) {
-      const index = isNumber(keyOrIndex) ? keyOrIndex : this.#order.indexOf(key);
-      if (index >= 0)
-        this.#order.splice(index, 1);
-      this.#order = this.#order.filter(() => true);
-      notifyWatchers(this.#watchers);
+    return node.value;
+  }
+  const initialKeys = Array.from(source.keys());
+  for (const key of initialKeys)
+    addSignal(key);
+  node.value = initialKeys;
+  const collection = {
+    [Symbol.toStringTag]: TYPE_COLLECTION,
+    [Symbol.isConcatSpreadable]: true,
+    *[Symbol.iterator]() {
+      for (const key of node.value) {
+        const signal = signals.get(key);
+        if (signal)
+          yield signal;
+      }
+    },
+    get length() {
+      if (activeSink)
+        link(node, activeSink);
+      return ensureSynced().length;
+    },
+    keys() {
+      if (activeSink)
+        link(node, activeSink);
+      return ensureSynced().values();
+    },
+    get() {
+      if (activeSink)
+        link(node, activeSink);
+      const currentKeys = ensureSynced();
+      const result = [];
+      for (const key of currentKeys) {
+        try {
+          const v = signals.get(key)?.get();
+          if (v != null)
+            result.push(v);
+        } catch (e) {
+          if (!(e instanceof UnsetSignalValueError))
+            throw e;
+        }
+      }
+      return result;
+    },
+    at(index) {
+      return signals.get(node.value[index]);
+    },
+    byKey(key) {
+      return signals.get(key);
+    },
+    keyAt(index) {
+      return node.value[index];
+    },
+    indexOfKey(key) {
+      return node.value.indexOf(key);
+    },
+    deriveCollection(cb) {
+      return deriveCollection(collection, cb);
     }
-  }
-  sort(compareFn) {
-    const entries = this.#order.map((key) => [key, this.#composite.signals.get(key)?.get()]).sort(isFunction(compareFn) ? (a, b) => compareFn(a[1], b[1]) : (a, b) => String(a[1]).localeCompare(String(b[1])));
-    const newOrder = entries.map(([key]) => key);
-    if (!isEqual(this.#order, newOrder)) {
-      this.#order = newOrder;
-      notifyWatchers(this.#watchers);
-      triggerHook(this.#hookCallbacks.sort, this.#order);
+  };
+  return collection;
+}
+function createCollection(start, options) {
+  const initialValue = options?.value ?? [];
+  if (initialValue.length)
+    validateSignalValue(TYPE_COLLECTION, initialValue, Array.isArray);
+  validateCallback(TYPE_COLLECTION, start);
+  const signals = new Map;
+  const keys = [];
+  let keyCounter = 0;
+  const keyConfig = options?.keyConfig;
+  const generateKey = typeof keyConfig === "string" ? () => `${keyConfig}${keyCounter++}` : isFunction(keyConfig) ? (item) => keyConfig(item) : () => String(keyCounter++);
+  const itemFactory = options?.createItem ?? ((_key, value) => createState(value));
+  function buildValue() {
+    const result = [];
+    for (const key of keys) {
+      try {
+        const v = signals.get(key)?.get();
+        if (v != null)
+          result.push(v);
+      } catch (e) {
+        if (!(e instanceof UnsetSignalValueError))
+          throw e;
+      }
     }
+    return result;
+  }
+  const node = {
+    fn: buildValue,
+    value: initialValue,
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    equals: () => false,
+    error: undefined
+  };
+  function applyChanges(changes) {
+    if (!changes.changed)
+      return;
+    let structural = false;
+    batch(() => {
+      for (const key in changes.add) {
+        const value = changes.add[key];
+        signals.set(key, itemFactory(key, value));
+        if (!keys.includes(key))
+          keys.push(key);
+        structural = true;
+      }
+      for (const key in changes.change) {
+        const signal = signals.get(key);
+        if (signal && isState(signal)) {
+          signal.set(changes.change[key]);
+        }
+      }
+      for (const key in changes.remove) {
+        signals.delete(key);
+        const index = keys.indexOf(key);
+        if (index !== -1)
+          keys.splice(index, 1);
+        structural = true;
+      }
+      if (structural) {
+        node.sources = null;
+        node.sourcesTail = null;
+      }
+      node.flags = FLAG_CLEAN;
+      propagate(node);
+      node.flags |= FLAG_DIRTY;
+    });
   }
-  splice(start, deleteCount, ...items) {
-    const length = this.#order.length;
-    const actualStart = start < 0 ? Math.max(0, length + start) : Math.min(start, length);
-    const actualDeleteCount = Math.max(0, Math.min(deleteCount ?? Math.max(0, length - Math.max(0, actualStart)), length - actualStart));
-    const add = {};
-    const remove = {};
-    for (let i = 0;i < actualDeleteCount; i++) {
-      const index = actualStart + i;
-      const key = this.#order[index];
-      if (key) {
-        const signal = this.#composite.signals.get(key);
+  for (const item of initialValue) {
+    const key = generateKey(item);
+    signals.set(key, itemFactory(key, item));
+    keys.push(key);
+  }
+  node.value = initialValue;
+  node.flags = FLAG_DIRTY;
+  function startWatching() {
+    if (!node.sinks)
+      node.stop = start(applyChanges);
+  }
+  const collection = {
+    [Symbol.toStringTag]: TYPE_COLLECTION,
+    [Symbol.isConcatSpreadable]: true,
+    *[Symbol.iterator]() {
+      for (const key of keys) {
+        const signal = signals.get(key);
         if (signal)
-          remove[key] = signal.get();
+          yield signal;
+      }
+    },
+    get length() {
+      if (activeSink) {
+        startWatching();
+        link(node, activeSink);
+      }
+      return keys.length;
+    },
+    keys() {
+      if (activeSink) {
+        startWatching();
+        link(node, activeSink);
+      }
+      return keys.values();
+    },
+    get() {
+      if (activeSink) {
+        startWatching();
+        link(node, activeSink);
+      }
+      if (node.sources) {
+        if (node.flags) {
+          node.value = untrack(buildValue);
+          node.flags = FLAG_CLEAN;
+        }
+      } else {
+        refresh(node);
+        if (node.error)
+          throw node.error;
       }
+      return node.value;
+    },
+    at(index) {
+      return signals.get(keys[index]);
+    },
+    byKey(key) {
+      return signals.get(key);
+    },
+    keyAt(index) {
+      return keys[index];
+    },
+    indexOfKey(key) {
+      return keys.indexOf(key);
+    },
+    deriveCollection(cb) {
+      return deriveCollection(collection, cb);
     }
-    const newOrder = this.#order.slice(0, actualStart);
-    for (const item of items) {
-      const key = this.#generateKey(item);
-      newOrder.push(key);
-      add[key] = item;
+  };
+  return collection;
+}
+function isCollection(value) {
+  return isObjectOfType(value, TYPE_COLLECTION);
+}
+function isCollectionSource(value) {
+  return isList(value) || isCollection(value);
+}
+// src/nodes/effect.ts
+function createEffect(fn) {
+  validateCallback("Effect", fn);
+  const node = {
+    fn,
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    cleanup: null
+  };
+  const dispose = () => {
+    runCleanup(node);
+    node.fn = undefined;
+    node.flags = FLAG_CLEAN;
+    node.sourcesTail = null;
+    trimSources(node);
+  };
+  if (activeOwner)
+    registerCleanup(activeOwner, dispose);
+  runEffect(node);
+  return dispose;
+}
+function match(signals, handlers) {
+  if (!activeOwner)
+    throw new RequiredOwnerError("match");
+  const { ok, err = console.error, nil } = handlers;
+  let errors;
+  let pending = false;
+  const values = new Array(signals.length);
+  for (let i = 0;i < signals.length; i++) {
+    try {
+      values[i] = signals[i].get();
+    } catch (e) {
+      if (e instanceof UnsetSignalValueError) {
+        pending = true;
+        continue;
+      }
+      if (!errors)
+        errors = [];
+      errors.push(e instanceof Error ? e : new Error(String(e)));
     }
-    newOrder.push(...this.#order.slice(actualStart + actualDeleteCount));
-    const changed = !!(Object.keys(add).length || Object.keys(remove).length);
-    if (changed) {
-      this.#composite.change({
-        add,
-        change: {},
-        remove,
-        changed
-      });
-      this.#order = newOrder.filter(() => true);
-      notifyWatchers(this.#watchers);
+  }
+  let out;
+  try {
+    if (pending)
+      out = nil?.();
+    else if (errors)
+      out = err(errors);
+    else
+      out = ok(values);
+  } catch (e) {
+    err([e instanceof Error ? e : new Error(String(e))]);
+  }
+  if (typeof out === "function")
+    return out;
+  if (out instanceof Promise) {
+    const owner = activeOwner;
+    const controller = new AbortController;
+    registerCleanup(owner, () => controller.abort());
+    out.then((cleanup) => {
+      if (!controller.signal.aborted && typeof cleanup === "function")
+        registerCleanup(owner, cleanup);
+    }).catch((e) => {
+      err([e instanceof Error ? e : new Error(String(e))]);
+    });
+  }
+}
+// src/nodes/sensor.ts
+function createSensor(start, options) {
+  validateCallback(TYPE_SENSOR, start, isSyncFunction);
+  if (options?.value !== undefined)
+    validateSignalValue(TYPE_SENSOR, options.value, options?.guard);
+  const node = {
+    value: options?.value,
+    sinks: null,
+    sinksTail: null,
+    equals: options?.equals ?? DEFAULT_EQUALITY,
+    guard: options?.guard,
+    stop: undefined
+  };
+  return {
+    [Symbol.toStringTag]: TYPE_SENSOR,
+    get() {
+      if (activeSink) {
+        if (!node.sinks)
+          node.stop = start((next) => {
+            validateSignalValue(TYPE_SENSOR, next, node.guard);
+            setState(node, next);
+          });
+        link(node, activeSink);
+      }
+      validateReadValue(TYPE_SENSOR, node.value);
+      return node.value;
     }
-    return Object.values(remove);
+  };
+}
+function isSensor(value) {
+  return isObjectOfType(value, TYPE_SENSOR);
+}
+// src/nodes/store.ts
+function diffRecords(oldObj, newObj) {
+  const oldValid = isRecord(oldObj) || Array.isArray(oldObj);
+  const newValid = isRecord(newObj) || Array.isArray(newObj);
+  if (!oldValid || !newValid) {
+    const changed2 = !Object.is(oldObj, newObj);
+    return {
+      changed: changed2,
+      add: changed2 && newValid ? newObj : {},
+      change: {},
+      remove: changed2 && oldValid ? oldObj : {}
+    };
   }
-  on(type, callback) {
-    if (isHandledHook(type, [HOOK_SORT, HOOK_WATCH])) {
-      this.#hookCallbacks[type] ||= new Set;
-      this.#hookCallbacks[type].add(callback);
-      return () => {
-        this.#hookCallbacks[type]?.delete(callback);
-      };
-    } else if (isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE])) {
-      return this.#composite.on(type, callback);
+  const visited = new WeakSet;
+  const add = {};
+  const change = {};
+  const remove = {};
+  let changed = false;
+  const oldKeys = Object.keys(oldObj);
+  const newKeys = Object.keys(newObj);
+  for (const key of newKeys) {
+    if (key in oldObj) {
+      if (!isEqual(oldObj[key], newObj[key], visited)) {
+        change[key] = newObj[key];
+        changed = true;
+      }
+    } else {
+      add[key] = newObj[key];
+      changed = true;
     }
-    throw new InvalidHookError(TYPE_LIST, type);
   }
-  deriveCollection(callback) {
-    return new DerivedCollection(this, callback);
+  for (const key of oldKeys) {
+    if (!(key in newObj)) {
+      remove[key] = undefined;
+      changed = true;
+    }
   }
+  return { add, change, remove, changed };
 }
-var isList = (value) => isObjectOfType(value, TYPE_LIST);
-
-// src/classes/store.ts
-var TYPE_STORE = "Store";
-
-class BaseStore {
-  #composite;
-  #watchers = new Set;
-  #watchHookCallbacks;
-  constructor(initialValue) {
-    validateSignalValue(TYPE_STORE, initialValue, isRecord);
-    this.#composite = new Composite(initialValue, (key, value) => {
-      validateSignalValue(`${TYPE_STORE} for key "${key}"`, value);
-      return true;
-    }, (value) => createMutableSignal(value));
-  }
-  get #value() {
+function createStore(initialValue, options) {
+  validateSignalValue(TYPE_STORE, initialValue, isRecord);
+  const signals = new Map;
+  const addSignal = (key, value) => {
+    validateSignalValue(`${TYPE_STORE} for key "${key}"`, value);
+    if (Array.isArray(value))
+      signals.set(key, createList(value));
+    else if (isRecord(value))
+      signals.set(key, createStore(value));
+    else
+      signals.set(key, createState(value));
+  };
+  const buildValue = () => {
     const record = {};
-    for (const [key, signal] of this.#composite.signals.entries())
+    signals.forEach((signal, key) => {
       record[key] = signal.get();
+    });
     return record;
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_STORE;
-  }
-  get [Symbol.isConcatSpreadable]() {
-    return false;
-  }
-  *[Symbol.iterator]() {
-    for (const [key, signal] of this.#composite.signals.entries())
-      yield [key, signal];
-  }
-  keys() {
-    return this.#composite.signals.keys();
-  }
-  byKey(key) {
-    return this.#composite.signals.get(key);
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks);
-    return this.#value;
-  }
-  set(newValue) {
-    if (UNSET === newValue) {
-      this.#composite.clear();
-      notifyWatchers(this.#watchers);
-      this.#watchers.clear();
-      return;
+  };
+  const node = {
+    fn: buildValue,
+    value: initialValue,
+    flags: FLAG_DIRTY,
+    sources: null,
+    sourcesTail: null,
+    sinks: null,
+    sinksTail: null,
+    equals: isEqual,
+    error: undefined
+  };
+  const applyChanges = (changes) => {
+    let structural = false;
+    for (const key in changes.add) {
+      addSignal(key, changes.add[key]);
+      structural = true;
     }
-    const oldValue = this.#value;
-    const changed = this.#composite.change(diff(oldValue, newValue));
-    if (changed)
-      notifyWatchers(this.#watchers);
-  }
-  update(fn) {
-    this.set(fn(this.get()));
-  }
-  add(key, value) {
-    if (this.#composite.signals.has(key))
-      throw new DuplicateKeyError(TYPE_STORE, key, value);
-    const ok = this.#composite.add(key, value);
-    if (ok)
-      notifyWatchers(this.#watchers);
-    return key;
-  }
-  remove(key) {
-    const ok = this.#composite.remove(key);
-    if (ok)
-      notifyWatchers(this.#watchers);
-  }
-  on(type, callback) {
-    if (type === HOOK_WATCH) {
-      this.#watchHookCallbacks ||= new Set;
-      this.#watchHookCallbacks.add(callback);
-      return () => {
-        this.#watchHookCallbacks?.delete(callback);
-      };
-    } else if (isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE])) {
-      return this.#composite.on(type, callback);
+    if (Object.keys(changes.change).length) {
+      batch(() => {
+        for (const key in changes.change) {
+          const value = changes.change[key];
+          validateSignalValue(`${TYPE_STORE} for key "${key}"`, value);
+          const signal = signals.get(key);
+          if (signal) {
+            if (isRecord(value) !== isStore(signal)) {
+              addSignal(key, value);
+              structural = true;
+            } else
+              signal.set(value);
+          }
+        }
+      });
     }
-    throw new InvalidHookError(TYPE_STORE, type);
-  }
-}
-var createStore = (initialValue) => {
-  const instance = new BaseStore(initialValue);
-  return new Proxy(instance, {
+    for (const key in changes.remove) {
+      signals.delete(key);
+      structural = true;
+    }
+    if (structural) {
+      node.sources = null;
+      node.sourcesTail = null;
+    }
+    return changes.changed;
+  };
+  for (const key of Object.keys(initialValue))
+    addSignal(key, initialValue[key]);
+  const store = {
+    [Symbol.toStringTag]: TYPE_STORE,
+    [Symbol.isConcatSpreadable]: false,
+    *[Symbol.iterator]() {
+      for (const key of Array.from(signals.keys())) {
+        const signal = signals.get(key);
+        if (signal)
+          yield [key, signal];
+      }
+    },
+    keys() {
+      if (activeSink) {
+        if (!node.sinks && options?.watched)
+          node.stop = options.watched();
+        link(node, activeSink);
+      }
+      return signals.keys();
+    },
+    byKey(key) {
+      return signals.get(key);
+    },
+    get() {
+      if (activeSink) {
+        if (!node.sinks && options?.watched)
+          node.stop = options.watched();
+        link(node, activeSink);
+      }
+      if (node.sources) {
+        if (node.flags) {
+          node.value = untrack(buildValue);
+          node.flags = FLAG_CLEAN;
+        }
+      } else {
+        refresh(node);
+        if (node.error)
+          throw node.error;
+      }
+      return node.value;
+    },
+    set(newValue) {
+      const currentValue = node.flags & FLAG_DIRTY ? buildValue() : node.value;
+      const changes = diffRecords(currentValue, newValue);
+      if (applyChanges(changes)) {
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+    },
+    update(fn) {
+      store.set(fn(store.get()));
+    },
+    add(key, value) {
+      if (signals.has(key))
+        throw new DuplicateKeyError(TYPE_STORE, key, value);
+      addSignal(key, value);
+      node.sources = null;
+      node.sourcesTail = null;
+      propagate(node);
+      node.flags |= FLAG_DIRTY;
+      if (batchDepth === 0)
+        flush();
+      return key;
+    },
+    remove(key) {
+      const ok = signals.delete(key);
+      if (ok) {
+        node.sources = null;
+        node.sourcesTail = null;
+        propagate(node);
+        node.flags |= FLAG_DIRTY;
+        if (batchDepth === 0)
+          flush();
+      }
+    }
+  };
+  return new Proxy(store, {
     get(target, prop) {
       if (prop in target) {
         const value = Reflect.get(target, prop);
         return isFunction(value) ? value.bind(target) : value;
       }
-      if (!isSymbol(prop))
+      if (typeof prop !== "symbol")
         return target.byKey(prop);
     },
     has(target, prop) {
@@ -880,7 +1389,7 @@ var createStore = (initialValue) => {
     getOwnPropertyDescriptor(target, prop) {
       if (prop in target)
         return Reflect.getOwnPropertyDescriptor(target, prop);
-      if (isSymbol(prop))
+      if (typeof prop === "symbol")
         return;
       const signal = target.byKey(String(prop));
       return signal ? {
@@ -891,453 +1400,96 @@ var createStore = (initialValue) => {
       } : undefined;
     }
   });
-};
-var isStore = (value) => isObjectOfType(value, TYPE_STORE);
-
+}
+function isStore(value) {
+  return isObjectOfType(value, TYPE_STORE);
+}
 // src/signal.ts
-var isSignal = (value) => isState(value) || isComputed(value) || isStore(value);
-var isMutableSignal = (value) => isState(value) || isStore(value) || isList(value);
+function createComputed(callback, options) {
+  return isAsyncFunction(callback) ? createTask(callback, options) : createMemo(callback, options);
+}
 function createSignal(value) {
-  if (isMemoCallback(value))
-    return new Memo(value);
-  if (isTaskCallback(value))
-    return new Task(value);
+  if (isSignal(value))
+    return value;
+  if (value == null)
+    throw new InvalidSignalValueError("createSignal", value);
+  if (isAsyncFunction(value))
+    return createTask(value);
+  if (isFunction(value))
+    return createMemo(value);
   if (isUniformArray(value))
-    return new List(value);
+    return createList(value);
   if (isRecord(value))
     return createStore(value);
-  return new State(value);
+  return createState(value);
 }
 function createMutableSignal(value) {
+  if (isMutableSignal(value))
+    return value;
+  if (value == null || isFunction(value) || isSignal(value))
+    throw new InvalidSignalValueError("createMutableSignal", value);
   if (isUniformArray(value))
-    return new List(value);
+    return createList(value);
   if (isRecord(value))
     return createStore(value);
-  return new State(value);
+  return createState(value);
 }
-
-// src/errors.ts
-class CircularDependencyError extends Error {
-  constructor(where) {
-    super(`Circular dependency detected in ${where}`);
-    this.name = "CircularDependencyError";
-  }
+function isComputed(value) {
+  return isMemo(value) || isTask(value);
 }
-
-class DuplicateKeyError extends Error {
-  constructor(where, key, value) {
-    super(`Could not add ${where} key "${key}"${value ? ` with value ${valueString(value)}` : ""} because it already exists`);
-    this.name = "DuplicateKeyError";
-  }
-}
-
-class InvalidCallbackError extends TypeError {
-  constructor(where, value) {
-    super(`Invalid ${where} callback ${valueString(value)}`);
-    this.name = "InvalidCallbackError";
-  }
+function isSignal(value) {
+  const signalsTypes = [
+    TYPE_STATE,
+    TYPE_MEMO,
+    TYPE_TASK,
+    TYPE_SENSOR,
+    TYPE_LIST,
+    TYPE_COLLECTION,
+    TYPE_STORE
+  ];
+  const typeStyle = Object.prototype.toString.call(value).slice(8, -1);
+  return signalsTypes.includes(typeStyle);
 }
-
-class InvalidCollectionSourceError extends TypeError {
-  constructor(where, value) {
-    super(`Invalid ${where} source ${valueString(value)}`);
-    this.name = "InvalidCollectionSourceError";
-  }
-}
-
-class InvalidHookError extends TypeError {
-  constructor(where, type) {
-    super(`Invalid hook "${type}" in  ${where}`);
-    this.name = "InvalidHookError";
-  }
-}
-
-class InvalidSignalValueError extends TypeError {
-  constructor(where, value) {
-    super(`Invalid signal value ${valueString(value)} in ${where}`);
-    this.name = "InvalidSignalValueError";
-  }
-}
-
-class NullishSignalValueError extends TypeError {
-  constructor(where) {
-    super(`Nullish signal values are not allowed in ${where}`);
-    this.name = "NullishSignalValueError";
-  }
-}
-
-class ReadonlySignalError extends Error {
-  constructor(what, value) {
-    super(`Could not set ${what} to ${valueString(value)} because signal is read-only`);
-    this.name = "ReadonlySignalError";
-  }
-}
-var createError = (reason) => reason instanceof Error ? reason : Error(String(reason));
-var validateCallback = (where, value, guard = isFunction) => {
-  if (!guard(value))
-    throw new InvalidCallbackError(where, value);
-};
-var validateSignalValue = (where, value, guard = () => !(isSymbol(value) && value !== UNSET) || isFunction(value)) => {
-  if (value == null)
-    throw new NullishSignalValueError(where);
-  if (!guard(value))
-    throw new InvalidSignalValueError(where, value);
-};
-var guardMutableSignal = (what, value, signal) => {
-  if (!isMutableSignal(signal))
-    throw new ReadonlySignalError(what, value);
-  return true;
-};
-
-// src/classes/collection.ts
-var TYPE_COLLECTION = "Collection";
-
-class DerivedCollection {
-  #watchers = new Set;
-  #source;
-  #callback;
-  #signals = new Map;
-  #ownWatchers = new Map;
-  #hookCallbacks = {};
-  #order = [];
-  constructor(source, callback) {
-    validateCallback(TYPE_COLLECTION, callback);
-    if (isFunction(source))
-      source = source();
-    if (!isCollectionSource(source))
-      throw new InvalidCollectionSourceError(TYPE_COLLECTION, source);
-    this.#source = source;
-    this.#callback = callback;
-    for (let i = 0;i < this.#source.length; i++) {
-      const key = this.#source.keyAt(i);
-      if (!key)
-        continue;
-      this.#add(key);
-    }
-    this.#source.on(HOOK_ADD, (additions) => {
-      if (!additions)
-        return;
-      for (const key of additions) {
-        if (!this.#signals.has(key)) {
-          this.#add(key);
-          const signal = this.#signals.get(key);
-          if (signal && isAsyncCollectionCallback(this.#callback))
-            signal.get();
-        }
-      }
-      notifyWatchers(this.#watchers);
-      triggerHook(this.#hookCallbacks.add, additions);
-    });
-    this.#source.on(HOOK_REMOVE, (removals) => {
-      if (!removals)
-        return;
-      for (const key of removals) {
-        if (!this.#signals.has(key))
-          continue;
-        this.#signals.delete(key);
-        const index = this.#order.indexOf(key);
-        if (index >= 0)
-          this.#order.splice(index, 1);
-        const watcher = this.#ownWatchers.get(key);
-        if (watcher) {
-          watcher.stop();
-          this.#ownWatchers.delete(key);
-        }
-      }
-      this.#order = this.#order.filter(() => true);
-      notifyWatchers(this.#watchers);
-      triggerHook(this.#hookCallbacks.remove, removals);
-    });
-    this.#source.on(HOOK_SORT, (newOrder) => {
-      if (newOrder)
-        this.#order = [...newOrder];
-      notifyWatchers(this.#watchers);
-      triggerHook(this.#hookCallbacks.sort, newOrder);
-    });
-  }
-  #add(key) {
-    const computedCallback = isAsyncCollectionCallback(this.#callback) ? async (_, abort) => {
-      const sourceValue = this.#source.byKey(key)?.get();
-      if (sourceValue === UNSET)
-        return UNSET;
-      return this.#callback(sourceValue, abort);
-    } : () => {
-      const sourceValue = this.#source.byKey(key)?.get();
-      if (sourceValue === UNSET)
-        return UNSET;
-      return this.#callback(sourceValue);
-    };
-    const signal = createComputed(computedCallback);
-    this.#signals.set(key, signal);
-    if (!this.#order.includes(key))
-      this.#order.push(key);
-    if (this.#hookCallbacks.change?.size)
-      this.#addWatcher(key);
-    return true;
-  }
-  #addWatcher(key) {
-    const watcher = createWatcher(() => {
-      trackSignalReads(watcher, () => {
-        this.#signals.get(key)?.get();
-      });
-    });
-    this.#ownWatchers.set(key, watcher);
-    watcher();
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_COLLECTION;
-  }
-  get [Symbol.isConcatSpreadable]() {
-    return true;
-  }
-  *[Symbol.iterator]() {
-    for (const key of this.#order) {
-      const signal = this.#signals.get(key);
-      if (signal)
-        yield signal;
-    }
-  }
-  keys() {
-    return this.#order.values();
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH]);
-    return this.#order.map((key) => this.#signals.get(key)?.get()).filter((v) => v != null && v !== UNSET);
-  }
-  at(index) {
-    return this.#signals.get(this.#order[index]);
-  }
-  byKey(key) {
-    return this.#signals.get(key);
-  }
-  keyAt(index) {
-    return this.#order[index];
-  }
-  indexOfKey(key) {
-    return this.#order.indexOf(key);
-  }
-  on(type, callback) {
-    if (isHandledHook(type, [
-      HOOK_ADD,
-      HOOK_CHANGE,
-      HOOK_REMOVE,
-      HOOK_SORT,
-      HOOK_WATCH
-    ])) {
-      this.#hookCallbacks[type] ||= new Set;
-      this.#hookCallbacks[type].add(callback);
-      if (type === HOOK_CHANGE && !this.#ownWatchers.size) {
-        for (const key of this.#signals.keys())
-          this.#addWatcher(key);
-      }
-      return () => {
-        this.#hookCallbacks[type]?.delete(callback);
-        if (type === HOOK_CHANGE && !this.#hookCallbacks.change?.size) {
-          if (this.#ownWatchers.size) {
-            for (const watcher of this.#ownWatchers.values())
-              watcher.stop();
-            this.#ownWatchers.clear();
-          }
-        }
-      };
-    }
-    throw new InvalidHookError(TYPE_COLLECTION, type);
-  }
-  deriveCollection(callback) {
-    return new DerivedCollection(this, callback);
-  }
-  get length() {
-    subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH]);
-    return this.#order.length;
-  }
-}
-var isCollection = (value) => isObjectOfType(value, TYPE_COLLECTION);
-var isCollectionSource = (value) => isList(value) || isCollection(value);
-var isAsyncCollectionCallback = (callback) => isAsyncFunction(callback);
-// src/classes/ref.ts
-var TYPE_REF = "Ref";
-
-class Ref {
-  #watchers = new Set;
-  #value;
-  #watchHookCallbacks;
-  constructor(value, guard) {
-    validateSignalValue(TYPE_REF, value, guard);
-    this.#value = value;
-  }
-  get [Symbol.toStringTag]() {
-    return TYPE_REF;
-  }
-  get() {
-    subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks);
-    return this.#value;
-  }
-  notify() {
-    notifyWatchers(this.#watchers);
-  }
-  on(type, callback) {
-    if (type === HOOK_WATCH) {
-      this.#watchHookCallbacks ||= new Set;
-      this.#watchHookCallbacks.add(callback);
-      return () => {
-        this.#watchHookCallbacks?.delete(callback);
-      };
-    }
-    throw new InvalidHookError(TYPE_REF, type);
-  }
-}
-var isRef = (value) => isObjectOfType(value, TYPE_REF);
-// src/effect.ts
-var createEffect = (callback) => {
-  if (!isFunction(callback) || callback.length > 1)
-    throw new InvalidCallbackError("effect", callback);
-  const isAsync = isAsyncFunction(callback);
-  let running = false;
-  let controller;
-  const watcher = createWatcher(() => trackSignalReads(watcher, () => {
-    if (running)
-      throw new CircularDependencyError("effect");
-    running = true;
-    controller?.abort();
-    controller = undefined;
-    let cleanup;
-    try {
-      if (isAsync) {
-        controller = new AbortController;
-        const currentController = controller;
-        callback(controller.signal).then((cleanup2) => {
-          if (isFunction(cleanup2) && controller === currentController)
-            watcher.on(HOOK_CLEANUP, cleanup2);
-        }).catch((error) => {
-          if (!isAbortError(error))
-            console.error("Error in async effect callback:", error);
-        });
-      } else {
-        cleanup = callback();
-        if (isFunction(cleanup))
-          watcher.on(HOOK_CLEANUP, cleanup);
-      }
-    } catch (error) {
-      if (!isAbortError(error))
-        console.error("Error in effect callback:", error);
-    }
-    running = false;
-  }));
-  watcher();
-  return () => {
-    controller?.abort();
-    try {
-      watcher.stop();
-    } catch (error) {
-      console.error("Error in effect cleanup:", error);
-    }
-  };
-};
-// src/match.ts
-function match(result, handlers) {
-  try {
-    if (result.pending)
-      handlers.nil?.();
-    else if (result.errors)
-      handlers.err?.(result.errors);
-    else if (result.ok)
-      handlers.ok(result.values);
-  } catch (e) {
-    const error = createError(e);
-    if (handlers.err && (!result.errors || !result.errors.includes(error)))
-      handlers.err(result.errors ? [...result.errors, error] : [error]);
-    else
-      throw error;
-  }
-}
-// src/resolve.ts
-function resolve(signals) {
-  const errors = [];
-  let pending = false;
-  const values = {};
-  for (const [key, signal] of Object.entries(signals)) {
-    try {
-      const value = signal.get();
-      if (value === UNSET)
-        pending = true;
-      else
-        values[key] = value;
-    } catch (e) {
-      errors.push(createError(e));
-    }
-  }
-  if (pending)
-    return { ok: false, pending: true };
-  if (errors.length > 0)
-    return { ok: false, errors };
-  return { ok: true, values };
+function isMutableSignal(value) {
+  return isState(value) || isStore(value) || isList(value);
 }
 export {
   valueString,
-  validateSignalValue,
-  validateCallback,
-  triggerHook,
-  trackSignalReads,
-  subscribeActiveWatcher,
-  resolve,
-  notifyWatchers,
+  untrack,
   match,
-  isTaskCallback,
-  isSymbol,
-  isString,
+  isTask,
   isStore,
   isState,
   isSignal,
-  isRef,
-  isRecordOrArray,
+  isSensor,
   isRecord,
   isObjectOfType,
-  isNumber,
   isMutableSignal,
-  isMemoCallback,
+  isMemo,
   isList,
-  isHandledHook,
   isFunction,
   isEqual,
   isComputed,
   isCollection,
   isAsyncFunction,
-  isAbortError,
-  guardMutableSignal,
-  flushPendingReactions,
-  diff,
-  createWatcher,
+  createTask,
   createStore,
+  createState,
   createSignal,
-  createError,
+  createSensor,
+  createScope,
+  createMutableSignal,
+  createMemo,
+  createList,
   createEffect,
   createComputed,
-  batchSignalWrites,
-  UNSET,
-  Task,
-  TYPE_STORE,
-  TYPE_STATE,
-  TYPE_REF,
-  TYPE_LIST,
-  TYPE_COMPUTED,
-  TYPE_COLLECTION,
-  State,
-  Ref,
-  ReadonlySignalError,
+  createCollection,
+  batch,
+  UnsetSignalValueError,
+  SKIP_EQUALITY,
+  RequiredOwnerError,
   NullishSignalValueError,
-  Memo,
-  List,
   InvalidSignalValueError,
-  InvalidCollectionSourceError,
   InvalidCallbackError,
-  HOOK_WATCH,
-  HOOK_SORT,
-  HOOK_REMOVE,
-  HOOK_CLEANUP,
-  HOOK_CHANGE,
-  HOOK_ADD,
-  DuplicateKeyError,
-  DerivedCollection,
-  CircularDependencyError,
-  BaseStore
+  CircularDependencyError
 };