what-core 0.11.0 → 0.11.1

package/dist/devtools.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/reactive.js"],
-  "sourcesContent": ["// What Framework - Reactive Primitives\n// Signals + Effects: fine-grained reactivity without virtual DOM overhead\n//\n// Upgrades:\n// - Topological ordering: computed/effects sorted by _level to prevent diamond glitches\n// - Iterative computed evaluation: no recursion, handles 10K+ depth chains\n// - Ownership tree: createRoot children auto-dispose when parent disposes\n// - Performance: cached levels, lazy sort, fast-path notify, minimal allocation\n\n// Dev-mode flag \u2014 build tools can dead-code-eliminate when false\nexport const __DEV__ = typeof process !== 'undefined'\n  ? process.env?.NODE_ENV !== 'production'\n  : true;\n\n// DevTools hooks \u2014 set by what-devtools when installed.\n// These are no-ops in production (dead-code eliminated with __DEV__).\nexport let __devtools = null;\n\n/** @internal Install devtools hooks. Called by what-devtools. */\nexport function __setDevToolsHooks(hooks) {\n  if (__DEV__) __devtools = hooks;\n}\n\nlet currentEffect = null;\nlet currentRoot = null;\nlet currentOwner = null;  // Ownership tree: tracks current owner context\nlet insideComputed = false; // Track whether we're inside a computed() callback (dev-mode warning)\nlet batchDepth = 0;\nlet pendingEffects = [];\nlet pendingNeedSort = false;  // Track whether pendingEffects actually needs sorting\n\n// WeakMap: subscriber Set \u2192 owning computed's inner effect (null/absent for signals)\n// Used for topological level computation.\nconst subSetOwner = new WeakMap();\n\n// --- Iterative Computed Evaluation State ---\n// Uses a throw/catch trampoline to convert recursive computed evaluation\n// to iterative. When a computed fn() reads another dirty computed, instead\n// of recursing, we throw a sentinel that gets caught by the outer loop.\nconst NEEDS_UPSTREAM = Symbol('needs_upstream');\nlet iterativeEvalStack = null;  // array when inside evaluation loop, null otherwise\n\n// --- Signal ---\n// A reactive value. Reading inside an effect auto-tracks the dependency.\n// Writing triggers only the effects that depend on this signal.\n\nexport function signal(initial, debugName) {\n  let value = initial;\n  const subs = new Set();\n\n  // Unified getter/setter: sig() reads, sig(newVal) writes\n  function sig(...args) {\n    if (args.length === 0) {\n      // Read\n      if (currentEffect) {\n        subs.add(currentEffect);\n        currentEffect.deps.push(subs);\n      }\n      return value;\n    }\n    // Write\n    if (__DEV__ && insideComputed) {\n      console.warn(\n        '[what] Signal.set() called inside a computed function. ' +\n        'This may cause infinite loops. Use effect() instead.' +\n        (debugName ? ` (signal: ${debugName})` : '')\n      );\n    }\n    const nextVal = typeof args[0] === 'function' ? args[0](value) : args[0];\n    if (Object.is(value, nextVal)) return;\n    value = nextVal;\n    if (__DEV__ && __devtools) __devtools.onSignalUpdate(sig);\n    if (subs.size > 0) notify(subs);\n  }\n\n  sig.set = (next) => {\n    if (__DEV__ && insideComputed) {\n      console.warn(\n        '[what] Signal.set() called inside a computed function. ' +\n        'This may cause infinite loops. Use effect() instead.' +\n        (debugName ? ` (signal: ${debugName})` : '')\n      );\n    }\n    const nextVal = typeof next === 'function' ? next(value) : next;\n    if (Object.is(value, nextVal)) return;\n    value = nextVal;\n    if (__DEV__ && __devtools) __devtools.onSignalUpdate(sig);\n    if (subs.size > 0) notify(subs);\n  };\n\n  sig.peek = () => value;\n\n  sig.subscribe = (fn) => {\n    return effect(() => fn(sig()));\n  };\n\n  sig._signal = true;\n  if (__DEV__) {\n    sig._subs = subs;\n    if (debugName) sig._debugName = debugName;\n  }\n\n  // Notify devtools of signal creation\n  if (__DEV__ && __devtools) __devtools.onSignalCreate(sig);\n\n  return sig;\n}\n\n// --- Computed ---\n// Derived signal. Lazy: only recomputes when a dependency changes AND it's read.\n// Topological level: max(dependency levels) + 1, computed from source signals (level 0).\n\nexport function computed(fn) {\n  let value, dirty = true;\n  const subs = new Set();\n\n  const inner = _createEffect(() => {\n    const prevInsideComputed = insideComputed;\n    if (__DEV__) insideComputed = true;\n    try {\n      value = fn();\n      dirty = false;\n    } finally {\n      if (__DEV__) insideComputed = prevInsideComputed;\n    }\n  }, true);\n\n  // Computed nodes start at level 1. Updated when graph structure changes.\n  inner._level = 1;\n  inner._computed = true;\n  inner._computedSubs = subs;\n\n  // Register this subscriber set as owned by this computed\n  subSetOwner.set(subs, inner);\n\n  // Store markDirty/isDirty closures on the inner effect for iterative eval\n  inner._markDirty = () => { dirty = true; };\n  inner._isDirty = () => dirty;\n\n  function read() {\n    if (currentEffect) {\n      subs.add(currentEffect);\n      currentEffect.deps.push(subs);\n    }\n    if (dirty) _evaluateComputed(inner);\n    return value;\n  }\n\n  // When a dependency changes, mark dirty AND propagate to our subscribers.\n  inner._onNotify = () => {\n    dirty = true;\n    if (subs.size > 0) notify(subs);\n  };\n\n  read._signal = true;\n  read.peek = () => {\n    if (dirty) _evaluateComputed(inner);\n    return value;\n  };\n\n  return read;\n}\n\n// --- Iterative Computed Evaluation ---\n//\n// Problem: A chain of N dirty computeds causes O(N) recursive calls:\n// C_N.read() \u2192 eval \u2192 fn() \u2192 C_{N-1}.read() \u2192 eval \u2192 fn() \u2192 ... \u2192 C_1.read() \u2192 eval \u2192 fn()\n// This overflows the stack at ~3500 depth.\n//\n// Solution: Throw/catch trampoline. The outermost _evaluateComputed manages a\n// stack (array). When a computed's fn() reads another dirty computed during\n// evaluation, _evaluateComputed throws NEEDS_UPSTREAM. The outer loop catches\n// this, adds the upstream to the stack, and processes from the bottom up.\n// This converts O(N) call depth to O(1) per computed (just the outermost loop).\n\nfunction _evaluateComputed(computedEffect) {\n  if (iterativeEvalStack !== null) {\n    // We're inside the outermost evaluation loop, and a computed's fn()\n    // is reading another dirty computed. Push it onto the stack and throw\n    // to abort the current fn() so the outer loop can process it first.\n    iterativeEvalStack.push(computedEffect);\n    throw NEEDS_UPSTREAM;\n  }\n\n  // Outermost call \u2014 enter the iterative evaluation loop.\n  // The stack grows as we discover dirty upstream computeds.\n  const stack = [computedEffect];\n  iterativeEvalStack = stack;\n\n  try {\n    while (stack.length > 0) {\n      const current = stack[stack.length - 1];\n\n      if (!current._isDirty || !current._isDirty()) {\n        // Already clean \u2014 pop and continue\n        stack.pop();\n        continue;\n      }\n\n      // Pre-scan known deps: if any are dirty computeds, push them onto\n      // the stack first (bottom-up). This avoids the O(N^2) worst case\n      // where throw/catch restarts from the top on each dirty upstream.\n      let pushedUpstream = false;\n      const deps = current.deps;\n      for (let i = 0; i < deps.length; i++) {\n        const depOwner = subSetOwner.get(deps[i]);\n        if (depOwner && depOwner._computed && depOwner._isDirty && depOwner._isDirty()) {\n          stack.push(depOwner);\n          pushedUpstream = true;\n        }\n      }\n      if (pushedUpstream) {\n        // Process dirty upstreams first before re-evaluating current\n        continue;\n      }\n\n      // All known deps are clean \u2014 evaluate. throw/catch is fallback\n      // for newly-discovered deps only.\n      try {\n        const prevDepsLen = current.deps.length;\n        _runEffect(current);\n        // Only recompute level when graph structure changes\n        if (current.deps.length !== prevDepsLen) {\n          _updateLevel(current);\n        }\n        stack.pop(); // Successfully evaluated\n      } catch (err) {\n        if (err === NEEDS_UPSTREAM) {\n          // A dirty upstream was discovered and pushed onto the stack.\n          // Re-mark this computed dirty since its fn() was aborted mid-execution.\n          current._markDirty();\n          // The upstream is now at stack[stack.length-1]. Loop continues.\n        } else {\n          throw err; // Re-throw real errors\n        }\n      }\n    }\n  } finally {\n    iterativeEvalStack = null;\n  }\n}\n\n// Update the topological level of a computed/effect based on its current dependencies.\nfunction _updateLevel(e) {\n  let maxDepLevel = 0;\n  const deps = e.deps;\n  for (let i = 0; i < deps.length; i++) {\n    const owner = subSetOwner.get(deps[i]);\n    if (owner) {\n      const depLevel = owner._level;\n      if (depLevel > maxDepLevel) maxDepLevel = depLevel;\n    }\n  }\n  e._level = maxDepLevel + 1;\n}\n\n// --- Effect ---\n// Runs a function, auto-tracking signal reads. Re-runs when deps change.\n// Returns a dispose function.\n\nexport function effect(fn, opts) {\n  const e = _createEffect(fn);\n  e._level = 1;\n  // First run: skip cleanup (deps is empty), just run and track\n  const prev = currentEffect;\n  currentEffect = e;\n  try {\n    const result = e.fn();\n    if (typeof result === 'function') e._cleanup = result;\n  } finally {\n    currentEffect = prev;\n  }\n  // Compute level after first run based on actual dependencies (cached).\n  _updateLevel(e);\n  // Mark as stable after first run \u2014 subsequent re-runs skip cleanup/re-subscribe\n  if (opts?.stable) e._stable = true;\n  const dispose = () => _disposeEffect(e);\n  // Register with current root for automatic cleanup\n  if (currentRoot) {\n    currentRoot.disposals.push(dispose);\n  }\n  return dispose;\n}\n\n// --- Batch ---\n// Group multiple signal writes; effects run once at the end.\n\nexport function batch(fn) {\n  batchDepth++;\n  try {\n    fn();\n  } finally {\n    batchDepth--;\n    if (batchDepth === 0) flush();\n  }\n}\n\n// --- Internals ---\n\nfunction _createEffect(fn, lazy) {\n  // Minimal object shape \u2014 computed() adds extra properties after creation.\n  // Keeping the base object small helps V8 optimize for the common (effect) case.\n  const e = {\n    fn,\n    deps: [],            // array of subscriber sets (cheaper than Set for typical 1-3 deps)\n    lazy: lazy || false,\n    _onNotify: null,\n    disposed: false,\n    _pending: false,\n    _stable: false,      // stable effects skip cleanup/re-subscribe on re-run\n    _level: 0,           // topological depth: signals=0, computed/effects=max(deps)+1\n    _computed: false,     // true for computed inner effects\n    _computedSubs: null,  // reference to the computed's subscriber set\n    _isDirty: null,       // function to check if computed is dirty (set by computed())\n    _markDirty: null,     // function to mark computed dirty (set by computed())\n  };\n  if (__DEV__ && __devtools) __devtools.onEffectCreate(e);\n  return e;\n}\n\nfunction _runEffect(e) {\n  if (e.disposed) return;\n\n  // Stable effect fast path: deps don't change, skip cleanup/re-subscribe.\n  if (e._stable) {\n    runStableEffect(e);\n    return;\n  }\n\n  cleanup(e);\n  // Run effect cleanup from previous run\n  runEffectCleanup(e, 'effect cleanup');\n  const prev = currentEffect;\n  currentEffect = e;\n  try {\n    const result = e.fn();\n    // Capture cleanup function if returned\n    if (typeof result === 'function') {\n      e._cleanup = result;\n    }\n  } catch (err) {\n    if (err === NEEDS_UPSTREAM) throw err; // Iterative eval sentinel \u2014 not a real error\n    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });\n    throw err;\n  } finally {\n    currentEffect = prev;\n  }\n  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);\n}\n\nfunction _disposeEffect(e) {\n  e.disposed = true;\n  if (__DEV__ && __devtools) __devtools.onEffectDispose(e);\n  cleanup(e);\n  // Run cleanup on dispose\n  runEffectCleanup(e, 'effect cleanup on dispose');\n}\n\nfunction reportEffectCleanupError(err, e, phase) {\n  if (__devtools?.onError) __devtools.onError(err, { type: 'effect-cleanup', effect: e, phase });\n  if (__DEV__) console.warn(`[what] Error in ${phase}:`, err);\n}\n\nfunction runEffectCleanup(e, phase) {\n  if (!e._cleanup) return;\n  const cleanupFn = e._cleanup;\n  e._cleanup = null;\n  try {\n    cleanupFn();\n  } catch (err) {\n    reportEffectCleanupError(err, e, phase);\n  }\n}\n\nfunction runStableEffect(e) {\n  const prev = currentEffect;\n  currentEffect = null; // Don't re-track deps (already subscribed)\n  try {\n    runEffectCleanup(e, 'stable effect cleanup');\n    const result = e.fn();\n    if (typeof result === 'function') e._cleanup = result;\n  } catch (err) {\n    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });\n    if (__DEV__) console.warn('[what] Error in stable effect:', err);\n  } finally {\n    currentEffect = prev;\n  }\n  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);\n}\n\nfunction cleanup(e) {\n  const deps = e.deps;\n  for (let i = 0; i < deps.length; i++) deps[i].delete(e);\n  deps.length = 0;\n}\n\n// --- Notification ---\n// Iterative notification to prevent stack overflow on deep computed chains.\n// Uses a reusable queue to avoid per-call array allocation.\n// When notify() encounters _onNotify callbacks (from computeds), those may\n// call notify() recursively. The queue drains iteratively in the outermost call.\n\nlet notifyDepth = 0;        // Tracks recursive notify depth\nlet notifyQueue = null;     // Reusable queue, allocated on first recursive call\nlet notifyQueueLen = 0;     // Length of the queue\n\nfunction notify(subs) {\n  // Fast path: no recursive notifications in progress \u2014 iterate directly.\n  // This avoids array allocation for the common case (signal \u2192 effects).\n  if (notifyDepth === 0) {\n    notifyDepth = 1;\n    try {\n      for (const e of subs) {\n        if (e.disposed) continue;\n        if (e._onNotify) {\n          // Computed subscriber: mark dirty and propagate.\n          // _onNotify may call notify() recursively \u2014 tracked by notifyDepth.\n          e._onNotify();\n        } else if (batchDepth === 0 && e._stable) {\n          runStableEffect(e);\n        } else if (!e._pending) {\n          e._pending = true;\n          const level = e._level;\n          const len = pendingEffects.length;\n          if (len > 0 && pendingEffects[len - 1]._level > level) {\n            pendingNeedSort = true;\n          }\n          pendingEffects.push(e);\n        }\n      }\n      // Drain any queued subscriber sets from recursive notify calls\n      if (notifyQueueLen > 0) {\n        let qi = 0;\n        while (qi < notifyQueueLen) {\n          const queuedSubs = notifyQueue[qi];\n          notifyQueue[qi] = null; // Allow GC\n          qi++;\n          for (const e of queuedSubs) {\n            if (e.disposed) continue;\n            if (e._onNotify) {\n              e._onNotify();\n            } else if (batchDepth === 0 && e._stable) {\n              runStableEffect(e);\n            } else if (!e._pending) {\n              e._pending = true;\n              const level = e._level;\n              const len = pendingEffects.length;\n              if (len > 0 && pendingEffects[len - 1]._level > level) {\n                pendingNeedSort = true;\n              }\n              pendingEffects.push(e);\n            }\n          }\n        }\n        notifyQueueLen = 0;\n      }\n    } finally {\n      notifyDepth = 0;\n    }\n    if (batchDepth === 0 && pendingEffects.length > 0) scheduleMicrotask();\n  } else {\n    // Recursive call \u2014 queue the subscriber set for the outermost call to drain.\n    if (notifyQueue === null) notifyQueue = [];\n    if (notifyQueueLen >= notifyQueue.length) {\n      notifyQueue.push(subs);\n    } else {\n      notifyQueue[notifyQueueLen] = subs;\n    }\n    notifyQueueLen++;\n  }\n}\n\nlet microtaskScheduled = false;\nfunction scheduleMicrotask() {\n  if (!microtaskScheduled) {\n    microtaskScheduled = true;\n    queueMicrotask(() => {\n      microtaskScheduled = false;\n      flush();\n    });\n  }\n}\n\nlet isFlushing = false;\n\nfunction flush() {\n  // Re-entrancy guard: if flush() is called during an active flush (e.g., via\n  // flushSync() inside a component render or effect), skip to prevent infinite\n  // recursion. Pending effects will be picked up by the outer flush's while-loop.\n  if (isFlushing) return;\n  isFlushing = true;\n\n  try {\n    let iterations = 0;\n    while (pendingEffects.length > 0 && iterations < 25) {\n      const batch = pendingEffects;\n      pendingEffects = [];\n\n      // Topological sort: execute effects in level order (lowest first).\n      // Fast paths:\n      // 1. Single effect \u2014 no sort needed (most common case for microtask flush)\n      // 2. Already sorted \u2014 skip sort (common when effects added in level order)\n      // 3. Multiple effects at different levels \u2014 sort required\n      if (batch.length > 1 && pendingNeedSort) {\n        batch.sort((a, b) => a._level - b._level);\n      }\n      pendingNeedSort = false;\n\n      for (let i = 0; i < batch.length; i++) {\n        const e = batch[i];\n        e._pending = false;\n        if (!e.disposed && !e._onNotify) {\n          const prevDepsLen = e.deps.length;\n          _runEffect(e);\n          // Update level only if deps changed (graph structure change)\n          if (!e._computed && e.deps.length !== prevDepsLen) {\n            _updateLevel(e);\n          }\n        }\n      }\n      iterations++;\n    }\n    if (iterations >= 25) {\n      // Clear pending effects to prevent further damage\n      for (let i = 0; i < pendingEffects.length; i++) pendingEffects[i]._pending = false;\n      pendingEffects.length = 0;\n\n      if (__DEV__) {\n        const remaining = pendingEffects.slice(0, 3);\n        const effectNames = remaining.map(e => e.fn?.name || e.fn?.toString().slice(0, 60) || '(anonymous)');\n        console.warn(\n          `[what] Possible infinite effect loop detected (25 iterations). ` +\n          `Likely cause: an effect writes to a signal it also reads, creating a cycle. ` +\n          `Use untrack() to read signals without subscribing. ` +\n          `Looping effects: ${effectNames.join(', ')}`\n        );\n      } else {\n        console.warn('[what] Possible infinite effect loop detected');\n      }\n    }\n  } finally {\n    isFlushing = false;\n  }\n}\n\n// --- Memo ---\n// Eager computed that only propagates when the value actually changes.\n// Fix: Instead of calling notify(subs) inline (which bypasses topological sort\n// and causes diamond-dependency glitches), push memo subscribers into\n// pendingEffects and let them go through the sorted flush() path.\nexport function memo(fn) {\n  let value;\n  const subs = new Set();\n\n  const e = _createEffect(() => {\n    const next = fn();\n    if (!Object.is(value, next)) {\n      value = next;\n      // Push subscribers into pendingEffects for topological flush\n      // instead of inline notify() which can cause diamond glitches\n      for (const sub of subs) {\n        if (sub.disposed) continue;\n        if (sub._onNotify) {\n          // Computed subscriber: mark dirty and propagate\n          sub._onNotify();\n        } else if (!sub._pending) {\n          sub._pending = true;\n          const level = sub._level;\n          const len = pendingEffects.length;\n          if (len > 0 && pendingEffects[len - 1]._level > level) {\n            pendingNeedSort = true;\n          }\n          pendingEffects.push(sub);\n        }\n      }\n    }\n  });\n\n  e._level = 1;\n\n  _runEffect(e);\n  _updateLevel(e);\n\n  // Register subscriber set owner for level tracking\n  subSetOwner.set(subs, e);\n\n  // Register with current root\n  if (currentRoot) {\n    currentRoot.disposals.push(() => _disposeEffect(e));\n  }\n\n  function read() {\n    if (currentEffect) {\n      subs.add(currentEffect);\n      currentEffect.deps.push(subs);\n    }\n    return value;\n  }\n\n  read._signal = true;\n  read.peek = () => value;\n  return read;\n}\n\n// --- flushSync ---\n// Force all pending effects to run synchronously. Use sparingly.\n// Calling during render or effect execution is a no-op (prevents infinite loops).\nexport function flushSync() {\n  if (isFlushing) {\n    // Re-entrant call \u2014 silently skip (Solid approach).\n    // This prevents infinite loops when flushSync() is called during component\n    // render or effect execution. Pending effects will be picked up by the\n    // outer flush's while-loop.\n    if (__DEV__) {\n      console.warn(\n        '[what] flushSync() called during an active flush (e.g., inside a component render or effect). ' +\n        'This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback.'\n      );\n    }\n    return;\n  }\n  if (currentEffect) {\n    // Called inside an effect/render \u2014 skip with warning\n    if (__DEV__) {\n      console.warn(\n        '[what] flushSync() called during effect execution. ' +\n        'This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback.'\n      );\n    }\n    return;\n  }\n  microtaskScheduled = false;\n  flush();\n}\n\n// --- Untrack ---\n// Read signals without subscribing\nexport function untrack(fn) {\n  const prev = currentEffect;\n  currentEffect = null;\n  try {\n    return fn();\n  } finally {\n    currentEffect = prev;\n  }\n}\n\n// --- getOwner / runWithOwner ---\n// Expose ownership context for advanced use cases (e.g., async operations\n// that need to register disposals with the correct owner).\n\nexport function getOwner() {\n  return currentOwner;\n}\n\nexport function runWithOwner(owner, fn) {\n  const prev = currentOwner;\n  const prevRoot = currentRoot;\n  currentOwner = owner;\n  currentRoot = owner;\n  try {\n    return fn();\n  } finally {\n    currentOwner = prev;\n    currentRoot = prevRoot;\n  }\n}\n\n// --- createRoot ---\n// Isolated reactive scope with ownership tree.\n// All effects created inside are tracked and disposed together.\n// Child createRoot scopes register with parent owner \u2014 disposing parent\n// automatically disposes all children (prevents orphaned subscriptions).\nexport function createRoot(fn) {\n  const prevRoot = currentRoot;\n  const prevOwner = currentOwner;\n  const root = {\n    disposals: [],\n    owner: currentOwner,     // parent owner for ownership tree\n    children: [],            // child roots (ownership tree)\n    _disposed: false,\n  };\n\n  // Register this root as a child of the parent owner\n  if (currentOwner) {\n    currentOwner.children.push(root);\n  }\n\n  currentRoot = root;\n  currentOwner = root;\n\n  try {\n    const dispose = () => {\n      if (root._disposed) return;\n      root._disposed = true;\n\n      // Dispose children first (depth-first, reverse order)\n      for (let i = root.children.length - 1; i >= 0; i--) {\n        _disposeRoot(root.children[i]);\n      }\n      root.children.length = 0;\n\n      // Dispose own effects (reverse order for LIFO cleanup)\n      for (let i = root.disposals.length - 1; i >= 0; i--) {\n        root.disposals[i]();\n      }\n      root.disposals.length = 0;\n\n      // Remove from parent's children list\n      if (root.owner) {\n        const idx = root.owner.children.indexOf(root);\n        if (idx >= 0) root.owner.children.splice(idx, 1);\n      }\n    };\n    return fn(dispose);\n  } finally {\n    currentRoot = prevRoot;\n    currentOwner = prevOwner;\n  }\n}\n\n// Internal: dispose a root and all its children\nfunction _disposeRoot(root) {\n  if (root._disposed) return;\n  root._disposed = true;\n\n  // Dispose children first\n  for (let i = root.children.length - 1; i >= 0; i--) {\n    _disposeRoot(root.children[i]);\n  }\n  root.children.length = 0;\n\n  // Dispose own effects\n  for (let i = root.disposals.length - 1; i >= 0; i--) {\n    root.disposals[i]();\n  }\n  root.disposals.length = 0;\n}\n\n// --- onCleanup ---\n// Register a cleanup function with the current owner/root.\n// Runs when the owner is disposed.\nexport function onCleanup(fn) {\n  if (currentRoot) {\n    currentRoot.disposals.push(fn);\n  }\n}\n"],
-  "mappings": ";AAUO,IAAM,UAAU,OAAO,YAAY,cACtC,OACA;AAIG,IAAI,aAAa;AAGjB,SAAS,mBAAmB,OAAO;AACxC,MAAI,QAAS,cAAa;AAC5B;",
-  "names": []
-}

package/dist/devtools.min.js

@@ -1,2 +0,0 @@
-var n=!(typeof process<"u"),t=null;function i(e){n&&(t=e)}export{i as __setDevToolsHooks};
-//# sourceMappingURL=devtools.min.js.map

package/dist/devtools.min.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/reactive.js"],
-  "sourcesContent": ["// What Framework - Reactive Primitives\n// Signals + Effects: fine-grained reactivity without virtual DOM overhead\n//\n// Upgrades:\n// - Topological ordering: computed/effects sorted by _level to prevent diamond glitches\n// - Iterative computed evaluation: no recursion, handles 10K+ depth chains\n// - Ownership tree: createRoot children auto-dispose when parent disposes\n// - Performance: cached levels, lazy sort, fast-path notify, minimal allocation\n\n// Dev-mode flag \u2014 build tools can dead-code-eliminate when false\nexport const __DEV__ = typeof process !== 'undefined'\n  ? process.env?.NODE_ENV !== 'production'\n  : true;\n\n// DevTools hooks \u2014 set by what-devtools when installed.\n// These are no-ops in production (dead-code eliminated with __DEV__).\nexport let __devtools = null;\n\n/** @internal Install devtools hooks. Called by what-devtools. */\nexport function __setDevToolsHooks(hooks) {\n  if (__DEV__) __devtools = hooks;\n}\n\nlet currentEffect = null;\nlet currentRoot = null;\nlet currentOwner = null;  // Ownership tree: tracks current owner context\nlet insideComputed = false; // Track whether we're inside a computed() callback (dev-mode warning)\nlet batchDepth = 0;\nlet pendingEffects = [];\nlet pendingNeedSort = false;  // Track whether pendingEffects actually needs sorting\n\n// WeakMap: subscriber Set \u2192 owning computed's inner effect (null/absent for signals)\n// Used for topological level computation.\nconst subSetOwner = new WeakMap();\n\n// --- Iterative Computed Evaluation State ---\n// Uses a throw/catch trampoline to convert recursive computed evaluation\n// to iterative. When a computed fn() reads another dirty computed, instead\n// of recursing, we throw a sentinel that gets caught by the outer loop.\nconst NEEDS_UPSTREAM = Symbol('needs_upstream');\nlet iterativeEvalStack = null;  // array when inside evaluation loop, null otherwise\n\n// --- Signal ---\n// A reactive value. Reading inside an effect auto-tracks the dependency.\n// Writing triggers only the effects that depend on this signal.\n\nexport function signal(initial, debugName) {\n  let value = initial;\n  const subs = new Set();\n\n  // Unified getter/setter: sig() reads, sig(newVal) writes\n  function sig(...args) {\n    if (args.length === 0) {\n      // Read\n      if (currentEffect) {\n        subs.add(currentEffect);\n        currentEffect.deps.push(subs);\n      }\n      return value;\n    }\n    // Write\n    if (__DEV__ && insideComputed) {\n      console.warn(\n        '[what] Signal.set() called inside a computed function. ' +\n        'This may cause infinite loops. Use effect() instead.' +\n        (debugName ? ` (signal: ${debugName})` : '')\n      );\n    }\n    const nextVal = typeof args[0] === 'function' ? args[0](value) : args[0];\n    if (Object.is(value, nextVal)) return;\n    value = nextVal;\n    if (__DEV__ && __devtools) __devtools.onSignalUpdate(sig);\n    if (subs.size > 0) notify(subs);\n  }\n\n  sig.set = (next) => {\n    if (__DEV__ && insideComputed) {\n      console.warn(\n        '[what] Signal.set() called inside a computed function. ' +\n        'This may cause infinite loops. Use effect() instead.' +\n        (debugName ? ` (signal: ${debugName})` : '')\n      );\n    }\n    const nextVal = typeof next === 'function' ? next(value) : next;\n    if (Object.is(value, nextVal)) return;\n    value = nextVal;\n    if (__DEV__ && __devtools) __devtools.onSignalUpdate(sig);\n    if (subs.size > 0) notify(subs);\n  };\n\n  sig.peek = () => value;\n\n  sig.subscribe = (fn) => {\n    return effect(() => fn(sig()));\n  };\n\n  sig._signal = true;\n  if (__DEV__) {\n    sig._subs = subs;\n    if (debugName) sig._debugName = debugName;\n  }\n\n  // Notify devtools of signal creation\n  if (__DEV__ && __devtools) __devtools.onSignalCreate(sig);\n\n  return sig;\n}\n\n// --- Computed ---\n// Derived signal. Lazy: only recomputes when a dependency changes AND it's read.\n// Topological level: max(dependency levels) + 1, computed from source signals (level 0).\n\nexport function computed(fn) {\n  let value, dirty = true;\n  const subs = new Set();\n\n  const inner = _createEffect(() => {\n    const prevInsideComputed = insideComputed;\n    if (__DEV__) insideComputed = true;\n    try {\n      value = fn();\n      dirty = false;\n    } finally {\n      if (__DEV__) insideComputed = prevInsideComputed;\n    }\n  }, true);\n\n  // Computed nodes start at level 1. Updated when graph structure changes.\n  inner._level = 1;\n  inner._computed = true;\n  inner._computedSubs = subs;\n\n  // Register this subscriber set as owned by this computed\n  subSetOwner.set(subs, inner);\n\n  // Store markDirty/isDirty closures on the inner effect for iterative eval\n  inner._markDirty = () => { dirty = true; };\n  inner._isDirty = () => dirty;\n\n  function read() {\n    if (currentEffect) {\n      subs.add(currentEffect);\n      currentEffect.deps.push(subs);\n    }\n    if (dirty) _evaluateComputed(inner);\n    return value;\n  }\n\n  // When a dependency changes, mark dirty AND propagate to our subscribers.\n  inner._onNotify = () => {\n    dirty = true;\n    if (subs.size > 0) notify(subs);\n  };\n\n  read._signal = true;\n  read.peek = () => {\n    if (dirty) _evaluateComputed(inner);\n    return value;\n  };\n\n  return read;\n}\n\n// --- Iterative Computed Evaluation ---\n//\n// Problem: A chain of N dirty computeds causes O(N) recursive calls:\n// C_N.read() \u2192 eval \u2192 fn() \u2192 C_{N-1}.read() \u2192 eval \u2192 fn() \u2192 ... \u2192 C_1.read() \u2192 eval \u2192 fn()\n// This overflows the stack at ~3500 depth.\n//\n// Solution: Throw/catch trampoline. The outermost _evaluateComputed manages a\n// stack (array). When a computed's fn() reads another dirty computed during\n// evaluation, _evaluateComputed throws NEEDS_UPSTREAM. The outer loop catches\n// this, adds the upstream to the stack, and processes from the bottom up.\n// This converts O(N) call depth to O(1) per computed (just the outermost loop).\n\nfunction _evaluateComputed(computedEffect) {\n  if (iterativeEvalStack !== null) {\n    // We're inside the outermost evaluation loop, and a computed's fn()\n    // is reading another dirty computed. Push it onto the stack and throw\n    // to abort the current fn() so the outer loop can process it first.\n    iterativeEvalStack.push(computedEffect);\n    throw NEEDS_UPSTREAM;\n  }\n\n  // Outermost call \u2014 enter the iterative evaluation loop.\n  // The stack grows as we discover dirty upstream computeds.\n  const stack = [computedEffect];\n  iterativeEvalStack = stack;\n\n  try {\n    while (stack.length > 0) {\n      const current = stack[stack.length - 1];\n\n      if (!current._isDirty || !current._isDirty()) {\n        // Already clean \u2014 pop and continue\n        stack.pop();\n        continue;\n      }\n\n      // Pre-scan known deps: if any are dirty computeds, push them onto\n      // the stack first (bottom-up). This avoids the O(N^2) worst case\n      // where throw/catch restarts from the top on each dirty upstream.\n      let pushedUpstream = false;\n      const deps = current.deps;\n      for (let i = 0; i < deps.length; i++) {\n        const depOwner = subSetOwner.get(deps[i]);\n        if (depOwner && depOwner._computed && depOwner._isDirty && depOwner._isDirty()) {\n          stack.push(depOwner);\n          pushedUpstream = true;\n        }\n      }\n      if (pushedUpstream) {\n        // Process dirty upstreams first before re-evaluating current\n        continue;\n      }\n\n      // All known deps are clean \u2014 evaluate. throw/catch is fallback\n      // for newly-discovered deps only.\n      try {\n        const prevDepsLen = current.deps.length;\n        _runEffect(current);\n        // Only recompute level when graph structure changes\n        if (current.deps.length !== prevDepsLen) {\n          _updateLevel(current);\n        }\n        stack.pop(); // Successfully evaluated\n      } catch (err) {\n        if (err === NEEDS_UPSTREAM) {\n          // A dirty upstream was discovered and pushed onto the stack.\n          // Re-mark this computed dirty since its fn() was aborted mid-execution.\n          current._markDirty();\n          // The upstream is now at stack[stack.length-1]. Loop continues.\n        } else {\n          throw err; // Re-throw real errors\n        }\n      }\n    }\n  } finally {\n    iterativeEvalStack = null;\n  }\n}\n\n// Update the topological level of a computed/effect based on its current dependencies.\nfunction _updateLevel(e) {\n  let maxDepLevel = 0;\n  const deps = e.deps;\n  for (let i = 0; i < deps.length; i++) {\n    const owner = subSetOwner.get(deps[i]);\n    if (owner) {\n      const depLevel = owner._level;\n      if (depLevel > maxDepLevel) maxDepLevel = depLevel;\n    }\n  }\n  e._level = maxDepLevel + 1;\n}\n\n// --- Effect ---\n// Runs a function, auto-tracking signal reads. Re-runs when deps change.\n// Returns a dispose function.\n\nexport function effect(fn, opts) {\n  const e = _createEffect(fn);\n  e._level = 1;\n  // First run: skip cleanup (deps is empty), just run and track\n  const prev = currentEffect;\n  currentEffect = e;\n  try {\n    const result = e.fn();\n    if (typeof result === 'function') e._cleanup = result;\n  } finally {\n    currentEffect = prev;\n  }\n  // Compute level after first run based on actual dependencies (cached).\n  _updateLevel(e);\n  // Mark as stable after first run \u2014 subsequent re-runs skip cleanup/re-subscribe\n  if (opts?.stable) e._stable = true;\n  const dispose = () => _disposeEffect(e);\n  // Register with current root for automatic cleanup\n  if (currentRoot) {\n    currentRoot.disposals.push(dispose);\n  }\n  return dispose;\n}\n\n// --- Batch ---\n// Group multiple signal writes; effects run once at the end.\n\nexport function batch(fn) {\n  batchDepth++;\n  try {\n    fn();\n  } finally {\n    batchDepth--;\n    if (batchDepth === 0) flush();\n  }\n}\n\n// --- Internals ---\n\nfunction _createEffect(fn, lazy) {\n  // Minimal object shape \u2014 computed() adds extra properties after creation.\n  // Keeping the base object small helps V8 optimize for the common (effect) case.\n  const e = {\n    fn,\n    deps: [],            // array of subscriber sets (cheaper than Set for typical 1-3 deps)\n    lazy: lazy || false,\n    _onNotify: null,\n    disposed: false,\n    _pending: false,\n    _stable: false,      // stable effects skip cleanup/re-subscribe on re-run\n    _level: 0,           // topological depth: signals=0, computed/effects=max(deps)+1\n    _computed: false,     // true for computed inner effects\n    _computedSubs: null,  // reference to the computed's subscriber set\n    _isDirty: null,       // function to check if computed is dirty (set by computed())\n    _markDirty: null,     // function to mark computed dirty (set by computed())\n  };\n  if (__DEV__ && __devtools) __devtools.onEffectCreate(e);\n  return e;\n}\n\nfunction _runEffect(e) {\n  if (e.disposed) return;\n\n  // Stable effect fast path: deps don't change, skip cleanup/re-subscribe.\n  if (e._stable) {\n    runStableEffect(e);\n    return;\n  }\n\n  cleanup(e);\n  // Run effect cleanup from previous run\n  runEffectCleanup(e, 'effect cleanup');\n  const prev = currentEffect;\n  currentEffect = e;\n  try {\n    const result = e.fn();\n    // Capture cleanup function if returned\n    if (typeof result === 'function') {\n      e._cleanup = result;\n    }\n  } catch (err) {\n    if (err === NEEDS_UPSTREAM) throw err; // Iterative eval sentinel \u2014 not a real error\n    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });\n    throw err;\n  } finally {\n    currentEffect = prev;\n  }\n  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);\n}\n\nfunction _disposeEffect(e) {\n  e.disposed = true;\n  if (__DEV__ && __devtools) __devtools.onEffectDispose(e);\n  cleanup(e);\n  // Run cleanup on dispose\n  runEffectCleanup(e, 'effect cleanup on dispose');\n}\n\nfunction reportEffectCleanupError(err, e, phase) {\n  if (__devtools?.onError) __devtools.onError(err, { type: 'effect-cleanup', effect: e, phase });\n  if (__DEV__) console.warn(`[what] Error in ${phase}:`, err);\n}\n\nfunction runEffectCleanup(e, phase) {\n  if (!e._cleanup) return;\n  const cleanupFn = e._cleanup;\n  e._cleanup = null;\n  try {\n    cleanupFn();\n  } catch (err) {\n    reportEffectCleanupError(err, e, phase);\n  }\n}\n\nfunction runStableEffect(e) {\n  const prev = currentEffect;\n  currentEffect = null; // Don't re-track deps (already subscribed)\n  try {\n    runEffectCleanup(e, 'stable effect cleanup');\n    const result = e.fn();\n    if (typeof result === 'function') e._cleanup = result;\n  } catch (err) {\n    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });\n    if (__DEV__) console.warn('[what] Error in stable effect:', err);\n  } finally {\n    currentEffect = prev;\n  }\n  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);\n}\n\nfunction cleanup(e) {\n  const deps = e.deps;\n  for (let i = 0; i < deps.length; i++) deps[i].delete(e);\n  deps.length = 0;\n}\n\n// --- Notification ---\n// Iterative notification to prevent stack overflow on deep computed chains.\n// Uses a reusable queue to avoid per-call array allocation.\n// When notify() encounters _onNotify callbacks (from computeds), those may\n// call notify() recursively. The queue drains iteratively in the outermost call.\n\nlet notifyDepth = 0;        // Tracks recursive notify depth\nlet notifyQueue = null;     // Reusable queue, allocated on first recursive call\nlet notifyQueueLen = 0;     // Length of the queue\n\nfunction notify(subs) {\n  // Fast path: no recursive notifications in progress \u2014 iterate directly.\n  // This avoids array allocation for the common case (signal \u2192 effects).\n  if (notifyDepth === 0) {\n    notifyDepth = 1;\n    try {\n      for (const e of subs) {\n        if (e.disposed) continue;\n        if (e._onNotify) {\n          // Computed subscriber: mark dirty and propagate.\n          // _onNotify may call notify() recursively \u2014 tracked by notifyDepth.\n          e._onNotify();\n        } else if (batchDepth === 0 && e._stable) {\n          runStableEffect(e);\n        } else if (!e._pending) {\n          e._pending = true;\n          const level = e._level;\n          const len = pendingEffects.length;\n          if (len > 0 && pendingEffects[len - 1]._level > level) {\n            pendingNeedSort = true;\n          }\n          pendingEffects.push(e);\n        }\n      }\n      // Drain any queued subscriber sets from recursive notify calls\n      if (notifyQueueLen > 0) {\n        let qi = 0;\n        while (qi < notifyQueueLen) {\n          const queuedSubs = notifyQueue[qi];\n          notifyQueue[qi] = null; // Allow GC\n          qi++;\n          for (const e of queuedSubs) {\n            if (e.disposed) continue;\n            if (e._onNotify) {\n              e._onNotify();\n            } else if (batchDepth === 0 && e._stable) {\n              runStableEffect(e);\n            } else if (!e._pending) {\n              e._pending = true;\n              const level = e._level;\n              const len = pendingEffects.length;\n              if (len > 0 && pendingEffects[len - 1]._level > level) {\n                pendingNeedSort = true;\n              }\n              pendingEffects.push(e);\n            }\n          }\n        }\n        notifyQueueLen = 0;\n      }\n    } finally {\n      notifyDepth = 0;\n    }\n    if (batchDepth === 0 && pendingEffects.length > 0) scheduleMicrotask();\n  } else {\n    // Recursive call \u2014 queue the subscriber set for the outermost call to drain.\n    if (notifyQueue === null) notifyQueue = [];\n    if (notifyQueueLen >= notifyQueue.length) {\n      notifyQueue.push(subs);\n    } else {\n      notifyQueue[notifyQueueLen] = subs;\n    }\n    notifyQueueLen++;\n  }\n}\n\nlet microtaskScheduled = false;\nfunction scheduleMicrotask() {\n  if (!microtaskScheduled) {\n    microtaskScheduled = true;\n    queueMicrotask(() => {\n      microtaskScheduled = false;\n      flush();\n    });\n  }\n}\n\nlet isFlushing = false;\n\nfunction flush() {\n  // Re-entrancy guard: if flush() is called during an active flush (e.g., via\n  // flushSync() inside a component render or effect), skip to prevent infinite\n  // recursion. Pending effects will be picked up by the outer flush's while-loop.\n  if (isFlushing) return;\n  isFlushing = true;\n\n  try {\n    let iterations = 0;\n    while (pendingEffects.length > 0 && iterations < 25) {\n      const batch = pendingEffects;\n      pendingEffects = [];\n\n      // Topological sort: execute effects in level order (lowest first).\n      // Fast paths:\n      // 1. Single effect \u2014 no sort needed (most common case for microtask flush)\n      // 2. Already sorted \u2014 skip sort (common when effects added in level order)\n      // 3. Multiple effects at different levels \u2014 sort required\n      if (batch.length > 1 && pendingNeedSort) {\n        batch.sort((a, b) => a._level - b._level);\n      }\n      pendingNeedSort = false;\n\n      for (let i = 0; i < batch.length; i++) {\n        const e = batch[i];\n        e._pending = false;\n        if (!e.disposed && !e._onNotify) {\n          const prevDepsLen = e.deps.length;\n          _runEffect(e);\n          // Update level only if deps changed (graph structure change)\n          if (!e._computed && e.deps.length !== prevDepsLen) {\n            _updateLevel(e);\n          }\n        }\n      }\n      iterations++;\n    }\n    if (iterations >= 25) {\n      // Clear pending effects to prevent further damage\n      for (let i = 0; i < pendingEffects.length; i++) pendingEffects[i]._pending = false;\n      pendingEffects.length = 0;\n\n      if (__DEV__) {\n        const remaining = pendingEffects.slice(0, 3);\n        const effectNames = remaining.map(e => e.fn?.name || e.fn?.toString().slice(0, 60) || '(anonymous)');\n        console.warn(\n          `[what] Possible infinite effect loop detected (25 iterations). ` +\n          `Likely cause: an effect writes to a signal it also reads, creating a cycle. ` +\n          `Use untrack() to read signals without subscribing. ` +\n          `Looping effects: ${effectNames.join(', ')}`\n        );\n      } else {\n        console.warn('[what] Possible infinite effect loop detected');\n      }\n    }\n  } finally {\n    isFlushing = false;\n  }\n}\n\n// --- Memo ---\n// Eager computed that only propagates when the value actually changes.\n// Fix: Instead of calling notify(subs) inline (which bypasses topological sort\n// and causes diamond-dependency glitches), push memo subscribers into\n// pendingEffects and let them go through the sorted flush() path.\nexport function memo(fn) {\n  let value;\n  const subs = new Set();\n\n  const e = _createEffect(() => {\n    const next = fn();\n    if (!Object.is(value, next)) {\n      value = next;\n      // Push subscribers into pendingEffects for topological flush\n      // instead of inline notify() which can cause diamond glitches\n      for (const sub of subs) {\n        if (sub.disposed) continue;\n        if (sub._onNotify) {\n          // Computed subscriber: mark dirty and propagate\n          sub._onNotify();\n        } else if (!sub._pending) {\n          sub._pending = true;\n          const level = sub._level;\n          const len = pendingEffects.length;\n          if (len > 0 && pendingEffects[len - 1]._level > level) {\n            pendingNeedSort = true;\n          }\n          pendingEffects.push(sub);\n        }\n      }\n    }\n  });\n\n  e._level = 1;\n\n  _runEffect(e);\n  _updateLevel(e);\n\n  // Register subscriber set owner for level tracking\n  subSetOwner.set(subs, e);\n\n  // Register with current root\n  if (currentRoot) {\n    currentRoot.disposals.push(() => _disposeEffect(e));\n  }\n\n  function read() {\n    if (currentEffect) {\n      subs.add(currentEffect);\n      currentEffect.deps.push(subs);\n    }\n    return value;\n  }\n\n  read._signal = true;\n  read.peek = () => value;\n  return read;\n}\n\n// --- flushSync ---\n// Force all pending effects to run synchronously. Use sparingly.\n// Calling during render or effect execution is a no-op (prevents infinite loops).\nexport function flushSync() {\n  if (isFlushing) {\n    // Re-entrant call \u2014 silently skip (Solid approach).\n    // This prevents infinite loops when flushSync() is called during component\n    // render or effect execution. Pending effects will be picked up by the\n    // outer flush's while-loop.\n    if (__DEV__) {\n      console.warn(\n        '[what] flushSync() called during an active flush (e.g., inside a component render or effect). ' +\n        'This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback.'\n      );\n    }\n    return;\n  }\n  if (currentEffect) {\n    // Called inside an effect/render \u2014 skip with warning\n    if (__DEV__) {\n      console.warn(\n        '[what] flushSync() called during effect execution. ' +\n        'This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback.'\n      );\n    }\n    return;\n  }\n  microtaskScheduled = false;\n  flush();\n}\n\n// --- Untrack ---\n// Read signals without subscribing\nexport function untrack(fn) {\n  const prev = currentEffect;\n  currentEffect = null;\n  try {\n    return fn();\n  } finally {\n    currentEffect = prev;\n  }\n}\n\n// --- getOwner / runWithOwner ---\n// Expose ownership context for advanced use cases (e.g., async operations\n// that need to register disposals with the correct owner).\n\nexport function getOwner() {\n  return currentOwner;\n}\n\nexport function runWithOwner(owner, fn) {\n  const prev = currentOwner;\n  const prevRoot = currentRoot;\n  currentOwner = owner;\n  currentRoot = owner;\n  try {\n    return fn();\n  } finally {\n    currentOwner = prev;\n    currentRoot = prevRoot;\n  }\n}\n\n// --- createRoot ---\n// Isolated reactive scope with ownership tree.\n// All effects created inside are tracked and disposed together.\n// Child createRoot scopes register with parent owner \u2014 disposing parent\n// automatically disposes all children (prevents orphaned subscriptions).\nexport function createRoot(fn) {\n  const prevRoot = currentRoot;\n  const prevOwner = currentOwner;\n  const root = {\n    disposals: [],\n    owner: currentOwner,     // parent owner for ownership tree\n    children: [],            // child roots (ownership tree)\n    _disposed: false,\n  };\n\n  // Register this root as a child of the parent owner\n  if (currentOwner) {\n    currentOwner.children.push(root);\n  }\n\n  currentRoot = root;\n  currentOwner = root;\n\n  try {\n    const dispose = () => {\n      if (root._disposed) return;\n      root._disposed = true;\n\n      // Dispose children first (depth-first, reverse order)\n      for (let i = root.children.length - 1; i >= 0; i--) {\n        _disposeRoot(root.children[i]);\n      }\n      root.children.length = 0;\n\n      // Dispose own effects (reverse order for LIFO cleanup)\n      for (let i = root.disposals.length - 1; i >= 0; i--) {\n        root.disposals[i]();\n      }\n      root.disposals.length = 0;\n\n      // Remove from parent's children list\n      if (root.owner) {\n        const idx = root.owner.children.indexOf(root);\n        if (idx >= 0) root.owner.children.splice(idx, 1);\n      }\n    };\n    return fn(dispose);\n  } finally {\n    currentRoot = prevRoot;\n    currentOwner = prevOwner;\n  }\n}\n\n// Internal: dispose a root and all its children\nfunction _disposeRoot(root) {\n  if (root._disposed) return;\n  root._disposed = true;\n\n  // Dispose children first\n  for (let i = root.children.length - 1; i >= 0; i--) {\n    _disposeRoot(root.children[i]);\n  }\n  root.children.length = 0;\n\n  // Dispose own effects\n  for (let i = root.disposals.length - 1; i >= 0; i--) {\n    root.disposals[i]();\n  }\n  root.disposals.length = 0;\n}\n\n// --- onCleanup ---\n// Register a cleanup function with the current owner/root.\n// Runs when the owner is disposed.\nexport function onCleanup(fn) {\n  if (currentRoot) {\n    currentRoot.disposals.push(fn);\n  }\n}\n"],
-  "mappings": "AAUO,IAAMA,EAAU,SAAO,QAAY,KAM/BC,EAAa,KAGjB,SAASC,EAAmBC,EAAO,CACpCH,IAASC,EAAaE,EAC5B",
-  "names": ["__DEV__", "__devtools", "__setDevToolsHooks", "hooks"]
-}

package/dist/dom.js

@@ -1,439 +0,0 @@
-import { effect, batch, untrack, signal, __DEV__, __devtools } from './reactive.js';
-import { reportError, _injectGetCurrentComponent, shallowEqual } from './components.js';
-import { _setComponentRef } from './helpers.js';
-const SVG_ELEMENTS = new Set([
-'svg', 'path', 'circle', 'rect', 'line', 'polyline', 'polygon', 'ellipse',
-'g', 'defs', 'use', 'symbol', 'clipPath', 'mask', 'pattern', 'image',
-'text', 'tspan', 'textPath', 'foreignObject', 'linearGradient', 'radialGradient', 'stop',
-'marker', 'animate', 'animateTransform', 'animateMotion', 'set', 'filter',
-'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix',
-'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage',
-'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'feSpecularLighting',
-'feTile', 'feTurbulence',
-]);
-const SVG_NS = 'http://www.w3.org/2000/svg';
-const mountedComponents = new Set();
-function isDomNode(value) {
-if (!value || typeof value !== 'object') return false;
-if (typeof Node !== 'undefined' && value instanceof Node) return true;
-return typeof value.nodeType === 'number' && typeof value.nodeName === 'string';
-}
-function isVNode(value) {
-return !!value && typeof value === 'object' && (value._vnode === true || 'tag' in value);
-}
-function disposeComponent(ctx) {
-if (ctx.disposed) return;
-ctx.disposed = true;
-if (ctx.cleanups) {
-for (const cleanup of ctx.cleanups) {
-try { cleanup(); } catch (e) { console.error('[what] cleanup error:', e); }
-}
-}
-if (ctx.effects) {
-for (const dispose of ctx.effects) {
-try { dispose(); } catch (e) {  }
-}
-}
-if (ctx.hooks) {
-for (const hook of ctx.hooks) {
-if (hook && typeof hook.cleanup === 'function') {
-try { hook.cleanup(); } catch (e) { console.error('[what] hook cleanup error:', e); }
-}
-}
-}
-if (ctx._cleanupCallbacks) {
-for (const fn of ctx._cleanupCallbacks) {
-try { fn(); } catch (e) { console.error('[what] onCleanup error:', e); }
-}
-}
-if (__DEV__ && __devtools?.onComponentUnmount) __devtools.onComponentUnmount(ctx);
-mountedComponents.delete(ctx);
-}
-export function disposeTree(node) {
-if (!node) return;
-if (node._componentCtx) {
-disposeComponent(node._componentCtx);
-}
-if (node._dispose) {
-try { node._dispose(); } catch (e) {  }
-}
-if (node._propEffects) {
-for (const key in node._propEffects) {
-try { node._propEffects[key](); } catch (e) {  }
-}
-}
-if (node.childNodes) {
-for (const child of node.childNodes) {
-disposeTree(child);
-}
-}
-}
-export function mount(vnode, container) {
-if (typeof container === 'string') {
-container = document.querySelector(container);
-}
-disposeTree(container); 
-container.textContent = '';
-const node = createDOM(vnode, container);
-if (node) container.appendChild(node);
-return () => {
-disposeTree(container);
-container.textContent = '';
-};
-}
-export function createDOM(vnode, parent, isSvg) {
-if (vnode == null || vnode === false || vnode === true) {
-return document.createComment('');
-}
-if (typeof vnode === 'string' || typeof vnode === 'number') {
-return document.createTextNode(String(vnode));
-}
-if (isDomNode(vnode)) {
-return vnode;
-}
-if (typeof vnode === 'function') {
-const container = document.createDocumentFragment ? document.createElement('span') : document.createElement('span');
-container.style.display = 'contents';
-let currentNodes = [];
-const dispose = effect(() => {
-const val = vnode();
-const vnodes = (val == null || val === false || val === true)
-? []
-: Array.isArray(val) ? val : [val];
-for (const old of currentNodes) {
-disposeTree(old);
-if (old.parentNode === container) container.removeChild(old);
-}
-currentNodes = [];
-for (const v of vnodes) {
-const node = createDOM(v, container, parent?._isSvg);
-if (node) {
-container.appendChild(node);
-currentNodes.push(node);
-}
-}
-});
-container._dispose = dispose;
-return container;
-}
-if (Array.isArray(vnode)) {
-const frag = document.createDocumentFragment();
-for (const child of vnode) {
-const node = createDOM(child, parent, isSvg);
-if (node) frag.appendChild(node);
-}
-return frag;
-}
-if (isVNode(vnode) && typeof vnode.tag === 'function') {
-return createComponent(vnode, parent, isSvg);
-}
-if (isVNode(vnode)) {
-return createElementFromVNode(vnode, parent, isSvg);
-}
-return document.createTextNode(String(vnode));
-}
-const componentStack = [];
-export function getCurrentComponent() {
-return componentStack[componentStack.length - 1];
-}
-_injectGetCurrentComponent(getCurrentComponent);
-_setComponentRef(getCurrentComponent);
-export function getComponentStack() {
-return componentStack;
-}
-function createComponent(vnode, parent, isSvg) {
-let { tag: Component, props, children } = vnode;
-if (typeof Component === 'function' &&
-(Component.prototype?.isReactComponent || Component.prototype?.render)) {
-const ClassComp = Component;
-Component = function ClassComponentBridge(props) {
-const instance = new ClassComp(props);
-return instance.render();
-};
-Component.displayName = ClassComp.displayName || ClassComp.name || 'ClassComponent';
-}
-if (Component === '__errorBoundary' || vnode.tag === '__errorBoundary') {
-return createErrorBoundary(vnode, parent);
-}
-if (Component === '__suspense' || vnode.tag === '__suspense') {
-return createSuspenseBoundary(vnode, parent);
-}
-if (Component === '__portal' || vnode.tag === '__portal') {
-return createPortalDOM(vnode, parent);
-}
-const ctx = {
-hooks: [],
-hookIndex: 0,
-effects: [],
-cleanups: [],
-mounted: false,
-disposed: false,
-Component,
-_parentCtx: componentStack[componentStack.length - 1] || null,
-_errorBoundary: (() => {
-let p = componentStack[componentStack.length - 1];
-while (p) {
-if (p._errorBoundary) return p._errorBoundary;
-p = p._parentCtx;
-}
-return null;
-})()
-};
-const container = document.createElement('span');
-container.style.display = 'contents';
-container._componentCtx = ctx;
-container._isSvg = !!isSvg;
-ctx._wrapper = container;
-mountedComponents.add(ctx);
-if (__DEV__ && __devtools?.onComponentMount) __devtools.onComponentMount(ctx);
-const propsChildren = children.length === 0 ? undefined : children.length === 1 ? children[0] : children;
-const propsSignal = signal({ ...props, children: propsChildren });
-ctx._propsSignal = propsSignal;
-componentStack.push(ctx);
-let result;
-try {
-result = Component(propsSignal());
-} catch (error) {
-componentStack.pop();
-if (!reportError(error, ctx)) {
-console.error('[what] Uncaught error in component:', Component.name || 'Anonymous', error);
-throw error;
-}
-return container;
-}
-componentStack.pop();
-ctx.mounted = true;
-if (ctx._mountCallbacks) {
-queueMicrotask(() => {
-if (ctx.disposed) return;
-for (const fn of ctx._mountCallbacks) {
-try { fn(); } catch (e) { console.error('[what] onMount error:', e); }
-}
-});
-}
-const vnodes = Array.isArray(result) ? result : [result];
-for (const v of vnodes) {
-const node = createDOM(v, container, isSvg);
-if (node) container.appendChild(node);
-}
-container._vnode = vnode;
-return container;
-}
-function createErrorBoundary(vnode, parent) {
-const { errorState, handleError, fallback, reset } = vnode.props;
-const children = vnode.children;
-const wrapper = document.createElement('span');
-wrapper.style.display = 'contents';
-const boundaryCtx = {
-hooks: [], hookIndex: 0, effects: [], cleanups: [],
-mounted: false, disposed: false,
-_parentCtx: componentStack[componentStack.length - 1] || null,
-_errorBoundary: handleError,
-};
-wrapper._componentCtx = boundaryCtx;
-const dispose = effect(() => {
-const error = errorState();
-componentStack.push(boundaryCtx);
-while (wrapper.firstChild) {
-disposeTree(wrapper.firstChild);
-wrapper.removeChild(wrapper.firstChild);
-}
-let vnodes;
-if (error) {
-vnodes = typeof fallback === 'function' ? [fallback({ error, reset })] : [fallback];
-} else {
-vnodes = children;
-}
-vnodes = Array.isArray(vnodes) ? vnodes : [vnodes];
-for (const v of vnodes) {
-const node = createDOM(v, wrapper);
-if (node) wrapper.appendChild(node);
-}
-componentStack.pop();
-});
-boundaryCtx.effects.push(dispose);
-return wrapper;
-}
-function createSuspenseBoundary(vnode, parent) {
-const { boundary, fallback, loading } = vnode.props;
-const children = vnode.children;
-const wrapper = document.createElement('span');
-wrapper.style.display = 'contents';
-const boundaryCtx = {
-hooks: [], hookIndex: 0, effects: [], cleanups: [],
-mounted: false, disposed: false,
-_parentCtx: componentStack[componentStack.length - 1] || null,
-};
-wrapper._componentCtx = boundaryCtx;
-const dispose = effect(() => {
-const isLoading = loading();
-const vnodes = isLoading ? [fallback] : children;
-const normalized = Array.isArray(vnodes) ? vnodes : [vnodes];
-componentStack.push(boundaryCtx);
-while (wrapper.firstChild) {
-disposeTree(wrapper.firstChild);
-wrapper.removeChild(wrapper.firstChild);
-}
-for (const v of normalized) {
-const node = createDOM(v, wrapper);
-if (node) wrapper.appendChild(node);
-}
-componentStack.pop();
-});
-boundaryCtx.effects.push(dispose);
-return wrapper;
-}
-function createPortalDOM(vnode, parent) {
-const { container } = vnode.props;
-const children = vnode.children;
-if (!container) {
-console.warn('[what] Portal: target container not found');
-return document.createComment('portal:empty');
-}
-const portalCtx = {
-hooks: [], hookIndex: 0, effects: [], cleanups: [],
-mounted: false, disposed: false,
-_parentCtx: componentStack[componentStack.length - 1] || null,
-};
-const placeholder = document.createComment('portal');
-placeholder._componentCtx = portalCtx;
-const portalNodes = [];
-for (const child of children) {
-const node = createDOM(child, container);
-if (node) {
-container.appendChild(node);
-portalNodes.push(node);
-}
-}
-portalCtx._cleanupCallbacks = [() => {
-for (const node of portalNodes) {
-disposeTree(node);
-if (node.parentNode) node.parentNode.removeChild(node);
-}
-}];
-return placeholder;
-}
-function createElementFromVNode(vnode, parent, isSvg) {
-const { tag, props, children } = vnode;
-const svgContext = isSvg || SVG_ELEMENTS.has(tag);
-const el = svgContext
-? document.createElementNS(SVG_NS, tag)
-: document.createElement(tag);
-if (props) {
-applyProps(el, props, {}, svgContext);
-}
-for (const child of children) {
-const node = createDOM(child, el, svgContext && tag !== 'foreignObject');
-if (node) el.appendChild(node);
-}
-el._vnode = vnode;
-return el;
-}
-function applyProps(el, newProps, oldProps, isSvg) {
-newProps = newProps || {};
-oldProps = oldProps || {};
-for (const key in newProps) {
-if (key === 'key' || key === 'children') continue;
-if (key === 'ref') {
-if (typeof newProps.ref === 'function') newProps.ref(el);
-else if (newProps.ref) newProps.ref.current = el;
-continue;
-}
-setProp(el, key, newProps[key], isSvg);
-}
-}
-function setProp(el, key, value, isSvg) {
-if (typeof value === 'function' && !(key.startsWith('on') && key.length > 2) && key !== 'ref') {
-if (!el._propEffects) el._propEffects = {};
-if (el._propEffects[key]) {
-try { el._propEffects[key](); } catch (e) {  }
-}
-el._propEffects[key] = effect(() => {
-const resolved = value();
-setProp(el, key, resolved, isSvg);
-});
-return;
-}
-if (key.startsWith('on') && key.length > 2) {
-let eventName = key.slice(2);
-let useCapture = false;
-if (eventName.endsWith('Capture')) {
-eventName = eventName.slice(0, -7);
-useCapture = true;
-}
-const event = eventName.toLowerCase();
-const storageKey = useCapture ? event + '_capture' : event;
-const old = el._events?.[storageKey];
-if (old && old._original === value) return;
-if (old) el.removeEventListener(event, old, useCapture);
-if (value == null) return;
-if (!el._events) el._events = {};
-const wrappedHandler = (e) => {
-if (!e.nativeEvent) e.nativeEvent = e;
-return untrack(() => value(e));
-};
-wrappedHandler._original = value;
-el._events[storageKey] = wrappedHandler;
-const eventOpts = value._eventOpts;
-el.addEventListener(event, wrappedHandler, eventOpts || useCapture || undefined);
-return;
-}
-if (key === 'className' || key === 'class') {
-if (isSvg) {
-el.setAttribute('class', value || '');
-} else {
-el.className = value || '';
-}
-return;
-}
-if (key === 'style') {
-if (typeof value === 'string') {
-el.style.cssText = value;
-el._prevStyle = null;
-} else if (typeof value === 'object') {
-const oldStyle = el._prevStyle || {};
-for (const prop in oldStyle) {
-if (!(prop in value)) el.style[prop] = '';
-}
-for (const prop in value) {
-el.style[prop] = value[prop] ?? '';
-}
-el._prevStyle = { ...value };
-}
-return;
-}
-if (key === 'dangerouslySetInnerHTML') {
-el.innerHTML = value?.__html ?? '';
-return;
-}
-if (key === 'innerHTML') {
-if (value && typeof value === 'object' && '__html' in value) {
-el.innerHTML = value.__html ?? '';
-} else {
-el.innerHTML = value ?? '';
-}
-return;
-}
-if (typeof value === 'boolean') {
-if (value) el.setAttribute(key, '');
-else el.removeAttribute(key);
-return;
-}
-if (key.startsWith('data-') || key.startsWith('aria-')) {
-el.setAttribute(key, value);
-return;
-}
-if (isSvg) {
-if (value === false || value == null) {
-el.removeAttribute(key);
-} else {
-el.setAttribute(key, value === true ? '' : String(value));
-}
-return;
-}
-if (key in el) {
-el[key] = value;
-} else {
-el.setAttribute(key, value);
-}
-}