@tachui/core 0.7.0-alpha1

package/dist/reactive/signal.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Signal implementation - core reactive primitive
+ *
+ * Signals are the foundation of TachUI's reactive system, providing
+ * fine-grained reactivity similar to SolidJS signals.
+ */
+import type { Computation, SignalImpl as ISignal } from './types';
+/**
+ * Signal setter function type
+ */
+export type SignalSetter<T> = (value: T | ((prev: T) => T)) => T;
+/**
+ * Internal signal implementation (keeping original behavior)
+ */
+declare class SignalImpl<T> implements ISignal<T> {
+    readonly id: number;
+    readonly observers: Set<Computation>;
+    private _value;
+    constructor(initialValue: T);
+    /**
+     * Get the current value and track dependency
+     */
+    getValue(): T;
+    /**
+     * Get the current value without tracking dependency
+     */
+    peek(): T;
+    /**
+     * Set a new value and notify observers
+     */
+    set(newValue: T | ((prev: T) => T)): T;
+    /**
+     * Notify all observers that this signal has changed
+     */
+    private notify;
+    /**
+     * Remove an observer (cleanup)
+     */
+    removeObserver(computation: Computation): void;
+}
+/**
+ * Flush all pending updates
+ */
+declare function flushUpdates(): void;
+/**
+ * Create a new reactive signal
+ *
+ * @param initialValue The initial value of the signal
+ * @returns A tuple of [getter, setter] functions
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = createSignal(0)
+ *
+ * console.log(count()) // 0
+ * setCount(5)
+ * console.log(count()) // 5
+ *
+ * // Functional update
+ * setCount(prev => prev + 1)
+ * console.log(count()) // 6
+ * ```
+ */
+export declare function createSignal<T>(initialValue: T): [() => T, SignalSetter<T>];
+/**
+ * Type guard to check if a value is a signal
+ */
+export declare function isSignal<T = any>(value: any): value is (() => T) & {
+    peek: () => T;
+};
+/**
+ * Get the underlying signal implementation for debugging
+ */
+export declare function getSignalImpl<T>(signal: (() => T) & {
+    peek: () => T;
+}): SignalImpl<T> | null;
+/**
+ * Public Signal type export (callable getter)
+ */
+export type { Signal } from './types';
+export { flushUpdates as flushSync };
+//# sourceMappingURL=signal.d.ts.map

package/dist/reactive/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,SAAS,CAAA;AAKjE;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAA;AAEhE;;GAEG;AACH,cAAM,UAAU,CAAC,CAAC,CAAE,YAAW,OAAO,CAAC,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,SAAS,mBAAyB;IAC3C,OAAO,CAAC,MAAM,CAAG;gBAEL,YAAY,EAAE,CAAC;IAK3B;;OAEG;IACH,QAAQ,IAAI,CAAC;IAUb;;OAEG;IACH,IAAI,IAAI,CAAC;IAIT;;OAEG;IACH,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;IAYtC;;OAEG;IACH,OAAO,CAAC,MAAM;IASd;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;CAe/C;AAmBD;;GAEG;AACH,iBAAS,YAAY,IAAI,IAAI,CAqB5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAe3E;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC,CAAA;CAAE,CAEpF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAE5F;AAED;;GAEG;AACH,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAGrC,OAAO,EAAE,YAAY,IAAI,SAAS,EAAE,CAAA"}

package/dist/reactive/signal.js

@@ -0,0 +1,96 @@
+import { getCurrentComputation as l, isBatchingUpdates as f, setFlushFunction as c } from "./context.js";
+import { ComputationState as s } from "./types.js";
+var d = Object.defineProperty, h = (e, t, i) => t in e ? d(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i, n = (e, t, i) => h(e, typeof t != "symbol" ? t + "" : t, i);
+let p = 0;
+class b {
+  constructor(t) {
+    n(this, "id"), n(this, "observers", /* @__PURE__ */ new Set()), n(this, "_value"), this.id = ++p, this._value = t;
+  }
+  /**
+   * Get the current value and track dependency
+   */
+  getValue() {
+    const t = l();
+    return t && t.state !== s.Disposed && (this.observers.add(t), t.sources.add(this)), this._value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Set a new value and notify observers
+   */
+  set(t) {
+    const i = typeof t == "function" ? t(this._value) : t;
+    return i !== this._value && (this._value = i, this.notify()), i;
+  }
+  /**
+   * Notify all observers that this signal has changed
+   */
+  notify() {
+    for (const t of this.observers)
+      t.state !== s.Disposed && (t.state = s.Dirty, m(t));
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(t) {
+    this.observers.delete(t);
+  }
+  /**
+   * Get debug information about this signal
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      value: this._value,
+      observerCount: this.observers.size,
+      type: "Signal"
+    };
+  }
+}
+const r = /* @__PURE__ */ new Set();
+let o = !1;
+function m(e) {
+  r.add(e), !o && !f() && queueMicrotask(a);
+}
+function a() {
+  if (!o) {
+    o = !0;
+    try {
+      for (; r.size > 0; ) {
+        const e = Array.from(r).sort((t, i) => t.id - i.id);
+        r.clear();
+        for (const t of e)
+          t.state === s.Dirty && t.execute();
+      }
+    } finally {
+      o = !1;
+    }
+  }
+}
+function y(e) {
+  const t = new b(e), i = t.getValue.bind(t);
+  i.peek = t.peek.bind(t);
+  const u = t.set.bind(t);
+  return Object.defineProperty(i, Symbol.for("tachui.signal"), {
+    value: t,
+    enumerable: !1
+  }), [i, u];
+}
+function _(e) {
+  return typeof e == "function" && Symbol.for("tachui.signal") in e;
+}
+function S(e) {
+  return e[Symbol.for("tachui.signal")] || null;
+}
+c(a);
+export {
+  y as createSignal,
+  a as flushSync,
+  S as getSignalImpl,
+  _ as isSignal
+};
+//# sourceMappingURL=signal.js.map

package/dist/reactive/signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.js","sources":["../../src/reactive/signal.ts"],"sourcesContent":["/**\n * Signal implementation - core reactive primitive\n *\n * Signals are the foundation of TachUI's reactive system, providing\n * fine-grained reactivity similar to SolidJS signals.\n */\n\nimport { getCurrentComputation, isBatchingUpdates, setFlushFunction } from './context'\nimport type { Computation, SignalImpl as ISignal } from './types'\nimport { ComputationState } from './types'\n\nlet signalIdCounter = 0\n\n/**\n * Signal setter function type\n */\nexport type SignalSetter<T> = (value: T | ((prev: T) => T)) => T\n\n/**\n * Internal signal implementation (keeping original behavior)\n */\nclass SignalImpl<T> implements ISignal<T> {\n  readonly id: number\n  readonly observers = new Set<Computation>()\n  private _value: T\n\n  constructor(initialValue: T) {\n    this.id = ++signalIdCounter\n    this._value = initialValue\n  }\n\n  /**\n   * Get the current value and track dependency\n   */\n  getValue(): T {\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      // Track this signal as a dependency\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n    return this._value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    return this._value\n  }\n\n  /**\n   * Set a new value and notify observers\n   */\n  set(newValue: T | ((prev: T) => T)): T {\n    const value =\n      typeof newValue === 'function' ? (newValue as (prev: T) => T)(this._value) : newValue\n\n    if (value !== this._value) {\n      this._value = value\n      this.notify()\n    }\n\n    return value\n  }\n\n  /**\n   * Notify all observers that this signal has changed\n   */\n  private notify(): void {\n    for (const observer of this.observers) {\n      if (observer.state !== ComputationState.Disposed) {\n        observer.state = ComputationState.Dirty\n        scheduleUpdate(observer)\n      }\n    }\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Get debug information about this signal\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      value: this._value,\n      observerCount: this.observers.size,\n      type: 'Signal',\n    }\n  }\n}\n\n/**\n * Update queue for batching reactive updates\n */\nconst updateQueue = new Set<Computation>()\nlet isFlushingUpdates = false\n\n/**\n * Schedule a computation for update\n */\nfunction scheduleUpdate(computation: Computation): void {\n  updateQueue.add(computation)\n\n  if (!isFlushingUpdates && !isBatchingUpdates()) {\n    queueMicrotask(flushUpdates)\n  }\n}\n\n/**\n * Flush all pending updates\n */\nfunction flushUpdates(): void {\n  if (isFlushingUpdates) return\n\n  isFlushingUpdates = true\n\n  try {\n    // Keep processing until no more computations are added\n    while (updateQueue.size > 0) {\n      // Process updates in order of computation ID for deterministic execution\n      const computations = Array.from(updateQueue).sort((a, b) => a.id - b.id)\n      updateQueue.clear()\n\n      for (const computation of computations) {\n        if (computation.state === ComputationState.Dirty) {\n          computation.execute()\n        }\n      }\n    }\n  } finally {\n    isFlushingUpdates = false\n  }\n}\n\n/**\n * Create a new reactive signal\n *\n * @param initialValue The initial value of the signal\n * @returns A tuple of [getter, setter] functions\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * console.log(count()) // 0\n * setCount(5)\n * console.log(count()) // 5\n *\n * // Functional update\n * setCount(prev => prev + 1)\n * console.log(count()) // 6\n * ```\n */\nexport function createSignal<T>(initialValue: T): [() => T, SignalSetter<T>] {\n  const signal = new SignalImpl(initialValue)\n\n  const getter = signal.getValue.bind(signal) as (() => T) & { peek: () => T }\n  getter.peek = signal.peek.bind(signal)\n\n  const setter: SignalSetter<T> = signal.set.bind(signal)\n\n  // Add debug information\n  Object.defineProperty(getter, Symbol.for('tachui.signal'), {\n    value: signal,\n    enumerable: false,\n  })\n\n  return [getter, setter]\n}\n\n/**\n * Type guard to check if a value is a signal\n */\nexport function isSignal<T = any>(value: any): value is (() => T) & { peek: () => T } {\n  return typeof value === 'function' && Symbol.for('tachui.signal') in value\n}\n\n/**\n * Get the underlying signal implementation for debugging\n */\nexport function getSignalImpl<T>(signal: (() => T) & { peek: () => T }): SignalImpl<T> | null {\n  return (signal as any)[Symbol.for('tachui.signal')] || null\n}\n\n/**\n * Public Signal type export (callable getter)\n */\nexport type { Signal } from './types'\n\n// Export flush function for testing and manual control\nexport { flushUpdates as flushSync }\n\n// Register flush function with context module\nsetFlushFunction(flushUpdates)\n"],"names":["signalIdCounter","SignalImpl","initialValue","__publicField","computation","getCurrentComputation","ComputationState","newValue","value","observer","scheduleUpdate","updateQueue","isFlushingUpdates","isBatchingUpdates","flushUpdates","computations","a","b","createSignal","signal","getter","setter","isSignal","getSignalImpl","setFlushFunction"],"mappings":";;;AAWA,IAAIA,IAAkB;AAUtB,MAAMC,EAAoC;AAAA,EAKxC,YAAYC,GAAiB;AAJ7B,IAAAC,EAAA,MAAS,IAAA,GACTA,EAAA,MAAS,iCAAgB,IAAA,CAAiB,GAC1CA,EAAA,MAAQ,QAAA,GAGN,KAAK,KAAK,EAAEH,GACZ,KAAK,SAASE;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,WAAc;AACZ,UAAME,IAAcC,EAAA;AACpB,WAAID,KAAeA,EAAY,UAAUE,EAAiB,aAExD,KAAK,UAAU,IAAIF,CAAW,GAC9BA,EAAY,QAAQ,IAAI,IAAI,IAEvB,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,OAAU;AACR,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,IAAIG,GAAmC;AACrC,UAAMC,IACJ,OAAOD,KAAa,aAAcA,EAA4B,KAAK,MAAM,IAAIA;AAE/E,WAAIC,MAAU,KAAK,WACjB,KAAK,SAASA,GACd,KAAK,OAAA,IAGAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,SAAe;AACrB,eAAWC,KAAY,KAAK;AAC1B,MAAIA,EAAS,UAAUH,EAAiB,aACtCG,EAAS,QAAQH,EAAiB,OAClCI,EAAeD,CAAQ;AAAA,EAG7B;AAAA;AAAA;AAAA;AAAA,EAKA,eAAeL,GAAgC;AAC7C,SAAK,UAAU,OAAOA,CAAW;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,CAAC,OAAO,IAAI,cAAc,CAAC,IAAY;AACrC,WAAO;AAAA,MACL,IAAI,KAAK;AAAA,MACT,OAAO,KAAK;AAAA,MACZ,eAAe,KAAK,UAAU;AAAA,MAC9B,MAAM;AAAA,IAAA;AAAA,EAEV;AACF;AAKA,MAAMO,wBAAkB,IAAA;AACxB,IAAIC,IAAoB;AAKxB,SAASF,EAAeN,GAAgC;AACtD,EAAAO,EAAY,IAAIP,CAAW,GAEvB,CAACQ,KAAqB,CAACC,OACzB,eAAeC,CAAY;AAE/B;AAKA,SAASA,IAAqB;AAC5B,MAAI,CAAAF,GAEJ;AAAA,IAAAA,IAAoB;AAEpB,QAAI;AAEF,aAAOD,EAAY,OAAO,KAAG;AAE3B,cAAMI,IAAe,MAAM,KAAKJ,CAAW,EAAE,KAAK,CAACK,GAAGC,MAAMD,EAAE,KAAKC,EAAE,EAAE;AACvE,QAAAN,EAAY,MAAA;AAEZ,mBAAWP,KAAeW;AACxB,UAAIX,EAAY,UAAUE,EAAiB,SACzCF,EAAY,QAAA;AAAA,MAGlB;AAAA,IACF,UAAA;AACE,MAAAQ,IAAoB;AAAA,IACtB;AAAA;AACF;AAqBO,SAASM,EAAgBhB,GAA6C;AAC3E,QAAMiB,IAAS,IAAIlB,EAAWC,CAAY,GAEpCkB,IAASD,EAAO,SAAS,KAAKA,CAAM;AAC1C,EAAAC,EAAO,OAAOD,EAAO,KAAK,KAAKA,CAAM;AAErC,QAAME,IAA0BF,EAAO,IAAI,KAAKA,CAAM;AAGtD,gBAAO,eAAeC,GAAQ,OAAO,IAAI,eAAe,GAAG;AAAA,IACzD,OAAOD;AAAA,IACP,YAAY;AAAA,EAAA,CACb,GAEM,CAACC,GAAQC,CAAM;AACxB;AAKO,SAASC,EAAkBd,GAAoD;AACpF,SAAO,OAAOA,KAAU,cAAc,OAAO,IAAI,eAAe,KAAKA;AACvE;AAKO,SAASe,EAAiBJ,GAA6D;AAC5F,SAAQA,EAAe,OAAO,IAAI,eAAe,CAAC,KAAK;AACzD;AAWAK,EAAiBV,CAAY;"}

package/dist/reactive/theme.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./signal.cjs"),i=require("./computed.cjs"),[r,m]=n.createSignal("light");function u(){const e=r();return e==="system"?t():e}function c(e){m(e)}const o=i.createComputed(()=>{const e=r();return e==="system"?t():e});function s(){return o}function t(){return typeof window<"u"&&window.matchMedia&&window.matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"}exports.detectSystemTheme=t;exports.getCurrentTheme=u;exports.getThemeSignal=s;exports.setTheme=c;
+//# sourceMappingURL=theme.cjs.map

package/dist/reactive/theme.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.cjs","sources":["../../src/reactive/theme.ts"],"sourcesContent":["/**\n * Theme Management System for TachUI\n *\n * Provides reactive theme management with light/dark mode support.\n */\n\nimport { createSignal } from './signal'\nimport { createComputed, type Computed } from './computed'\n\nexport type Theme = 'light' | 'dark' | 'system'\n\n// Global theme signal\nconst [currentTheme, setCurrentTheme] = createSignal<Theme>('light')\n\n// Function to get the current theme\nexport function getCurrentTheme(): Theme {\n  const theme = currentTheme()\n  if (theme === 'system') {\n    return detectSystemTheme()\n  }\n  return theme\n}\n\n// Function to set the theme\nexport function setTheme(theme: Theme): void {\n  setCurrentTheme(theme)\n}\n\n// Create a single shared computed theme signal\nconst themeComputed = createComputed(() => {\n  const theme = currentTheme()\n  if (theme === 'system') {\n    return detectSystemTheme()\n  }\n  return theme\n})\n\n// Function to get the reactive theme signal for use in reactive effects\nexport function getThemeSignal(): Computed<'light' | 'dark'> {\n  return themeComputed\n}\n\n// Auto-detect system theme\nexport function detectSystemTheme(): 'light' | 'dark' {\n  if (typeof window !== 'undefined' && window.matchMedia) {\n    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'\n  }\n  return 'light'\n}\n"],"names":["currentTheme","setCurrentTheme","createSignal","getCurrentTheme","theme","detectSystemTheme","setTheme","themeComputed","createComputed","getThemeSignal"],"mappings":"4IAYM,CAACA,EAAcC,CAAe,EAAIC,EAAAA,aAAoB,OAAO,EAG5D,SAASC,GAAyB,CACvC,MAAMC,EAAQJ,EAAA,EACd,OAAII,IAAU,SACLC,EAAA,EAEFD,CACT,CAGO,SAASE,EAASF,EAAoB,CAC3CH,EAAgBG,CAAK,CACvB,CAGA,MAAMG,EAAgBC,EAAAA,eAAe,IAAM,CACzC,MAAMJ,EAAQJ,EAAA,EACd,OAAII,IAAU,SACLC,EAAA,EAEFD,CACT,CAAC,EAGM,SAASK,GAA6C,CAC3D,OAAOF,CACT,CAGO,SAASF,GAAsC,CACpD,OAAI,OAAO,OAAW,KAAe,OAAO,YACnC,OAAO,WAAW,8BAA8B,EAAE,QAAU,OAE9D,OACT"}

package/dist/reactive/theme.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Theme Management System for TachUI
+ *
+ * Provides reactive theme management with light/dark mode support.
+ */
+import { type Computed } from './computed';
+export type Theme = 'light' | 'dark' | 'system';
+export declare function getCurrentTheme(): Theme;
+export declare function setTheme(theme: Theme): void;
+export declare function getThemeSignal(): Computed<'light' | 'dark'>;
+export declare function detectSystemTheme(): 'light' | 'dark';
+//# sourceMappingURL=theme.d.ts.map

package/dist/reactive/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/reactive/theme.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE1D,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;AAM/C,wBAAgB,eAAe,IAAI,KAAK,CAMvC;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE3C;AAYD,wBAAgB,cAAc,IAAI,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC,CAE3D;AAGD,wBAAgB,iBAAiB,IAAI,OAAO,GAAG,MAAM,CAKpD"}

package/dist/reactive/theme.js

@@ -0,0 +1,27 @@
+import { createSignal as n } from "./signal.js";
+import { createComputed as m } from "./computed.js";
+const [t, o] = n("light");
+function h() {
+  const e = t();
+  return e === "system" ? r() : e;
+}
+function s(e) {
+  o(e);
+}
+const i = m(() => {
+  const e = t();
+  return e === "system" ? r() : e;
+});
+function d() {
+  return i;
+}
+function r() {
+  return typeof window < "u" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+export {
+  r as detectSystemTheme,
+  h as getCurrentTheme,
+  d as getThemeSignal,
+  s as setTheme
+};
+//# sourceMappingURL=theme.js.map

package/dist/reactive/theme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.js","sources":["../../src/reactive/theme.ts"],"sourcesContent":["/**\n * Theme Management System for TachUI\n *\n * Provides reactive theme management with light/dark mode support.\n */\n\nimport { createSignal } from './signal'\nimport { createComputed, type Computed } from './computed'\n\nexport type Theme = 'light' | 'dark' | 'system'\n\n// Global theme signal\nconst [currentTheme, setCurrentTheme] = createSignal<Theme>('light')\n\n// Function to get the current theme\nexport function getCurrentTheme(): Theme {\n  const theme = currentTheme()\n  if (theme === 'system') {\n    return detectSystemTheme()\n  }\n  return theme\n}\n\n// Function to set the theme\nexport function setTheme(theme: Theme): void {\n  setCurrentTheme(theme)\n}\n\n// Create a single shared computed theme signal\nconst themeComputed = createComputed(() => {\n  const theme = currentTheme()\n  if (theme === 'system') {\n    return detectSystemTheme()\n  }\n  return theme\n})\n\n// Function to get the reactive theme signal for use in reactive effects\nexport function getThemeSignal(): Computed<'light' | 'dark'> {\n  return themeComputed\n}\n\n// Auto-detect system theme\nexport function detectSystemTheme(): 'light' | 'dark' {\n  if (typeof window !== 'undefined' && window.matchMedia) {\n    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'\n  }\n  return 'light'\n}\n"],"names":["currentTheme","setCurrentTheme","createSignal","getCurrentTheme","theme","detectSystemTheme","setTheme","themeComputed","createComputed","getThemeSignal"],"mappings":";;AAYA,MAAM,CAACA,GAAcC,CAAe,IAAIC,EAAoB,OAAO;AAG5D,SAASC,IAAyB;AACvC,QAAMC,IAAQJ,EAAA;AACd,SAAII,MAAU,WACLC,EAAA,IAEFD;AACT;AAGO,SAASE,EAASF,GAAoB;AAC3C,EAAAH,EAAgBG,CAAK;AACvB;AAGA,MAAMG,IAAgBC,EAAe,MAAM;AACzC,QAAMJ,IAAQJ,EAAA;AACd,SAAII,MAAU,WACLC,EAAA,IAEFD;AACT,CAAC;AAGM,SAASK,IAA6C;AAC3D,SAAOF;AACT;AAGO,SAASF,IAAsC;AACpD,SAAI,OAAO,SAAW,OAAe,OAAO,cACnC,OAAO,WAAW,8BAA8B,EAAE,UAAU,SAE9D;AACT;"}

package/dist/reactive/types.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var e=(r=>(r[r.Clean=0]="Clean",r[r.Check=1]="Check",r[r.Dirty=2]="Dirty",r[r.Disposed=3]="Disposed",r))(e||{});exports.ComputationState=e;
+//# sourceMappingURL=types.cjs.map

package/dist/reactive/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":["../../src/reactive/types.ts"],"sourcesContent":["/**\n * Core reactive system types\n */\n\n/**\n * A reactive accessor function that returns the current value\n */\nexport type Accessor<T = any> = () => T\n\n/**\n * A setter function that updates a reactive value\n */\nexport type Setter<T> = (value: T | ((prev: T) => T)) => T\n\n/**\n * Extract the value type from an Accessor\n */\nexport type AccessorValue<T> = T extends Accessor<infer U> ? U : never\n\n/**\n * Owner context for reactive computations and cleanup\n */\nexport interface Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context: Map<symbol, any>\n  readonly cleanups: CleanupFunction[]\n  readonly sources: Set<Computation>\n  disposed: boolean\n}\n\n/**\n * Base computation interface\n */\nexport interface Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources: Set<any>\n  readonly observers: Set<Computation>\n  state: ComputationState\n  value?: any\n  execute(): any\n  dispose(): void\n}\n\n/**\n * Computation state enum\n */\nexport enum ComputationState {\n  Clean = 0, // Up to date\n  Check = 1, // Potentially stale, needs checking\n  Dirty = 2, // Definitely stale, needs recomputation\n  Disposed = 3, // Disposed, should not be used\n}\n\n/**\n * Signal interface (internal)\n */\nexport interface SignalImpl<T> {\n  readonly id: number\n  readonly observers: Set<Computation>\n  getValue(): T\n  peek(): T\n}\n\n/**\n * Signal getter function type (what createSignal returns)\n */\nexport type Signal<T> = (() => T) & { peek(): T }\n\n/**\n * Effect function type\n */\nexport type EffectFunction<T = any> = (prev?: T) => T\n\n/**\n * Effect options\n */\nexport interface EffectOptions {\n  name?: string\n}\n\n/**\n * Cleanup function type\n */\nexport type CleanupFunction = () => void\n\n/**\n * Reactive context for tracking dependencies\n */\nexport interface ReactiveContext {\n  readonly computation: Computation | null\n  readonly batch: boolean\n}\n\n/**\n * Scheduler interface for managing updates\n */\nexport interface Scheduler {\n  schedule(fn: () => void): void\n  flush(): void\n}\n"],"names":["ComputationState"],"mappings":"gFAiDO,IAAKA,GAAAA,IACVA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,SAAW,CAAA,EAAX,WAJUA,IAAAA,GAAA,CAAA,CAAA"}

package/dist/reactive/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Core reactive system types
+ */
+/**
+ * A reactive accessor function that returns the current value
+ */
+export type Accessor<T = any> = () => T;
+/**
+ * A setter function that updates a reactive value
+ */
+export type Setter<T> = (value: T | ((prev: T) => T)) => T;
+/**
+ * Extract the value type from an Accessor
+ */
+export type AccessorValue<T> = T extends Accessor<infer U> ? U : never;
+/**
+ * Owner context for reactive computations and cleanup
+ */
+export interface Owner {
+    readonly id: number;
+    readonly parent: Owner | null;
+    readonly context: Map<symbol, any>;
+    readonly cleanups: CleanupFunction[];
+    readonly sources: Set<Computation>;
+    disposed: boolean;
+}
+/**
+ * Base computation interface
+ */
+export interface Computation {
+    readonly id: number;
+    readonly owner: Owner | null;
+    readonly fn: () => any;
+    readonly sources: Set<any>;
+    readonly observers: Set<Computation>;
+    state: ComputationState;
+    value?: any;
+    execute(): any;
+    dispose(): void;
+}
+/**
+ * Computation state enum
+ */
+export declare enum ComputationState {
+    Clean = 0,// Up to date
+    Check = 1,// Potentially stale, needs checking
+    Dirty = 2,// Definitely stale, needs recomputation
+    Disposed = 3
+}
+/**
+ * Signal interface (internal)
+ */
+export interface SignalImpl<T> {
+    readonly id: number;
+    readonly observers: Set<Computation>;
+    getValue(): T;
+    peek(): T;
+}
+/**
+ * Signal getter function type (what createSignal returns)
+ */
+export type Signal<T> = (() => T) & {
+    peek(): T;
+};
+/**
+ * Effect function type
+ */
+export type EffectFunction<T = any> = (prev?: T) => T;
+/**
+ * Effect options
+ */
+export interface EffectOptions {
+    name?: string;
+}
+/**
+ * Cleanup function type
+ */
+export type CleanupFunction = () => void;
+/**
+ * Reactive context for tracking dependencies
+ */
+export interface ReactiveContext {
+    readonly computation: Computation | null;
+    readonly batch: boolean;
+}
+/**
+ * Scheduler interface for managing updates
+ */
+export interface Scheduler {
+    schedule(fn: () => void): void;
+    flush(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/reactive/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/reactive/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,CAAA;AAEvC;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAA;AAE1D;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEtE;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAClC,QAAQ,CAAC,QAAQ,EAAE,eAAe,EAAE,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,CAAC,CAAA;IAClC,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,CAAA;IACpC,KAAK,EAAE,gBAAgB,CAAA;IACvB,KAAK,CAAC,EAAE,GAAG,CAAA;IACX,OAAO,IAAI,GAAG,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;GAEG;AACH,oBAAY,gBAAgB;IAC1B,KAAK,IAAI,CAAE,aAAa;IACxB,KAAK,IAAI,CAAE,oCAAoC;IAC/C,KAAK,IAAI,CAAE,wCAAwC;IACnD,QAAQ,IAAI;CACb;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,CAAA;IACpC,QAAQ,IAAI,CAAC,CAAA;IACb,IAAI,IAAI,CAAC,CAAA;CACV;AAED;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG;IAAE,IAAI,IAAI,CAAC,CAAA;CAAE,CAAA;AAEjD;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;AAErD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAA;AAExC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;IACxC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAC9B,KAAK,IAAI,IAAI,CAAA;CACd"}

package/dist/reactive/types.js

@@ -0,0 +1,5 @@
+var s = /* @__PURE__ */ ((r) => (r[r.Clean = 0] = "Clean", r[r.Check = 1] = "Check", r[r.Dirty = 2] = "Dirty", r[r.Disposed = 3] = "Disposed", r))(s || {});
+export {
+  s as ComputationState
+};
+//# sourceMappingURL=types.js.map

package/dist/reactive/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../src/reactive/types.ts"],"sourcesContent":["/**\n * Core reactive system types\n */\n\n/**\n * A reactive accessor function that returns the current value\n */\nexport type Accessor<T = any> = () => T\n\n/**\n * A setter function that updates a reactive value\n */\nexport type Setter<T> = (value: T | ((prev: T) => T)) => T\n\n/**\n * Extract the value type from an Accessor\n */\nexport type AccessorValue<T> = T extends Accessor<infer U> ? U : never\n\n/**\n * Owner context for reactive computations and cleanup\n */\nexport interface Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context: Map<symbol, any>\n  readonly cleanups: CleanupFunction[]\n  readonly sources: Set<Computation>\n  disposed: boolean\n}\n\n/**\n * Base computation interface\n */\nexport interface Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources: Set<any>\n  readonly observers: Set<Computation>\n  state: ComputationState\n  value?: any\n  execute(): any\n  dispose(): void\n}\n\n/**\n * Computation state enum\n */\nexport enum ComputationState {\n  Clean = 0, // Up to date\n  Check = 1, // Potentially stale, needs checking\n  Dirty = 2, // Definitely stale, needs recomputation\n  Disposed = 3, // Disposed, should not be used\n}\n\n/**\n * Signal interface (internal)\n */\nexport interface SignalImpl<T> {\n  readonly id: number\n  readonly observers: Set<Computation>\n  getValue(): T\n  peek(): T\n}\n\n/**\n * Signal getter function type (what createSignal returns)\n */\nexport type Signal<T> = (() => T) & { peek(): T }\n\n/**\n * Effect function type\n */\nexport type EffectFunction<T = any> = (prev?: T) => T\n\n/**\n * Effect options\n */\nexport interface EffectOptions {\n  name?: string\n}\n\n/**\n * Cleanup function type\n */\nexport type CleanupFunction = () => void\n\n/**\n * Reactive context for tracking dependencies\n */\nexport interface ReactiveContext {\n  readonly computation: Computation | null\n  readonly batch: boolean\n}\n\n/**\n * Scheduler interface for managing updates\n */\nexport interface Scheduler {\n  schedule(fn: () => void): void\n  flush(): void\n}\n"],"names":["ComputationState"],"mappings":"AAiDO,IAAKA,sBAAAA,OACVA,EAAAA,EAAA,QAAQ,CAAA,IAAR,SACAA,EAAAA,EAAA,QAAQ,CAAA,IAAR,SACAA,EAAAA,EAAA,QAAQ,CAAA,IAAR,SACAA,EAAAA,EAAA,WAAW,CAAA,IAAX,YAJUA,IAAAA,KAAA,CAAA,CAAA;"}

package/dist/reactive/unified-scheduler.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var d=Object.defineProperty,f=(r,e,t)=>e in r?d(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t,i=(r,e,t)=>f(r,typeof e!="symbol"?e+"":e,t),n=(r=>(r[r.Immediate=0]="Immediate",r[r.High=1]="High",r[r.Normal=2]="Normal",r[r.Low=3]="Low",r[r.Idle=4]="Idle",r))(n||{});class l extends Error{constructor(e,t,s){super(e),this.cause=t,this.node=s,this.name="ReactiveError"}}const h=class o{constructor(){i(this,"updateQueues",new Map),i(this,"isFlushPending",!1),i(this,"isDestroyed",!1),i(this,"errorHandlers",new Set),i(this,"maxRetries",3),i(this,"totalUpdateCycles",0),i(this,"totalUpdateTime",0),i(this,"errorCount",0),i(this,"nodeRegistry",new WeakSet);for(const e of Object.values(n))typeof e=="number"&&this.updateQueues.set(e,new Set)}static getInstance(){return o.instance||(o.instance=new o),o.instance}schedule(e){if(this.isDestroyed)return;this.nodeRegistry.add(e),this.getQueue(e.priority).add(e),this.isFlushPending||(this.isFlushPending=!0,this.scheduleFlush(e.priority))}async flush(){if(this.isDestroyed)return;this.isFlushPending=!1;const e=performance.now();try{for(const t of[0,1,2,3,4]){const s=this.updateQueues.get(t);if(!s||s.size===0)continue;const u=Array.from(s);s.clear();for(const a of u)try{await this.updateNodeWithRetry(a)}catch(c){this.handleReactiveError(new l(`Failed to update ${a.type} node ${a.id}`,c,a))}if(this.hasHigherPriorityWork(t))return this.flush()}this.totalUpdateCycles++}finally{const t=performance.now();this.totalUpdateTime+=t-e}}async updateNodeWithRetry(e,t=1){try{e.notify()}catch(s){if(t<this.maxRetries)return console.warn(`Reactive update failed, retrying (${t}/${this.maxRetries})`),await new Promise(u=>setTimeout(u,t*10)),this.updateNodeWithRetry(e,t+1);throw s}}scheduleFlush(e){switch(e){case 0:this.flush();break;case 1:queueMicrotask(()=>this.flush());break;case 2:typeof requestAnimationFrame<"u"?requestAnimationFrame(()=>this.flush()):queueMicrotask(()=>this.flush());break;case 3:case 4:typeof requestIdleCallback<"u"?requestIdleCallback(()=>this.flush(),{timeout:1e3}):setTimeout(()=>this.flush(),50);break}}hasHigherPriorityWork(e){for(let t=0;t<e;t++){const s=this.updateQueues.get(t);if(s&&s.size>0)return!0}return!1}getQueue(e){const t=this.updateQueues.get(e);if(!t)throw new Error(`Invalid priority level: ${e}`);return t}onError(e){return this.errorHandlers.add(e),()=>this.errorHandlers.delete(e)}handleReactiveError(e){this.errorCount++;let t=!1;for(const s of this.errorHandlers)try{s(e),t=!0}catch(u){console.error("Error handler threw error:",u)}if(!t&&(console.error("Unhandled reactive error:",e),process.env.NODE_ENV==="development"))throw e}getPerformanceMetrics(){let e=0;for(const t of this.updateQueues.values())e+=t.size;return{totalNodes:e,updateCycles:this.totalUpdateCycles,averageUpdateTime:this.totalUpdateCycles>0?this.totalUpdateTime/this.totalUpdateCycles:0,memoryUsage:this.estimateMemoryUsage(),errorCount:this.errorCount}}estimateMemoryUsage(){let e=0;for(const t of this.updateQueues.values())e+=t.size*50;return e+=this.errorHandlers.size*100,e}hasNode(e){for(const t of this.updateQueues.values())if(t.has(e))return!0;return!1}flushSync(){this.isFlushPending&&(this.isFlushPending=!1,this.flush())}clearPending(){for(const e of this.updateQueues.values())e.clear();this.isFlushPending=!1}destroy(){this.isDestroyed=!0;for(const e of this.updateQueues.values()){for(const t of e)try{t.cleanup()}catch(s){console.error("Error cleaning up reactive node:",s)}e.clear()}this.updateQueues.clear(),this.errorHandlers.clear(),o.instance=null}getDebugInfo(){const e={};for(const[t,s]of this.updateQueues)e[n[t]]=s.size;return{isFlushPending:this.isFlushPending,isDestroyed:this.isDestroyed,queueSizes:e,errorHandlerCount:this.errorHandlers.size,performance:this.getPerformanceMetrics()}}};i(h,"instance",null);let p=h;exports.ReactiveError=l;exports.ReactiveScheduler=p;exports.UpdatePriority=n;
+//# sourceMappingURL=unified-scheduler.cjs.map

package/dist/reactive/unified-scheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-scheduler.cjs","sources":["../../src/reactive/unified-scheduler.ts"],"sourcesContent":["/**\n * Unified Reactive Scheduler v2.0\n *\n * Eliminates duplicate update queues and provides enterprise-grade\n * reactive system with proper error handling and memory management.\n *\n * Replaces the existing duplicated queue systems in signal.ts and computed.ts\n */\n\nexport enum UpdatePriority {\n  Immediate = 0, // Synchronous updates (rare)\n  High = 1, // User interaction responses\n  Normal = 2, // Regular updates\n  Low = 3, // Background updates\n  Idle = 4, // Idle time updates\n}\n\nexport interface ReactiveNode {\n  readonly id: number\n  readonly type: 'signal' | 'computed' | 'effect'\n  readonly priority: UpdatePriority\n  notify(): void\n  cleanup(): void\n}\n\nexport class ReactiveError extends Error {\n  constructor(\n    message: string,\n    public readonly cause: any,\n    public readonly node: ReactiveNode\n  ) {\n    super(message)\n    this.name = 'ReactiveError'\n  }\n}\n\nexport interface ReactivePerformanceMetrics {\n  totalNodes: number\n  updateCycles: number\n  averageUpdateTime: number\n  memoryUsage: number\n  errorCount: number\n}\n\n/**\n * Unified reactive scheduler that replaces all duplicate queue systems\n */\nexport class ReactiveScheduler {\n  private static instance: ReactiveScheduler | null = null\n  private updateQueues = new Map<UpdatePriority, Set<ReactiveNode>>()\n  private isFlushPending = false\n  private isDestroyed = false\n\n  // Error handling\n  private errorHandlers = new Set<(error: ReactiveError) => void>()\n  private readonly maxRetries = 3\n\n  // Performance tracking\n  private totalUpdateCycles = 0\n  private totalUpdateTime = 0\n  private errorCount = 0\n  private nodeRegistry = new WeakSet<ReactiveNode>()\n\n  private constructor() {\n    // Initialize priority queues\n    for (const priority of Object.values(UpdatePriority)) {\n      if (typeof priority === 'number') {\n        this.updateQueues.set(priority, new Set())\n      }\n    }\n  }\n\n  static getInstance(): ReactiveScheduler {\n    if (!ReactiveScheduler.instance) {\n      ReactiveScheduler.instance = new ReactiveScheduler()\n    }\n    return ReactiveScheduler.instance\n  }\n\n  /**\n   * Schedule reactive node for update\n   */\n  schedule(node: ReactiveNode): void {\n    if (this.isDestroyed) return\n\n    this.nodeRegistry.add(node)\n    const queue = this.getQueue(node.priority)\n    queue.add(node)\n\n    if (!this.isFlushPending) {\n      this.isFlushPending = true\n      this.scheduleFlush(node.priority)\n    }\n  }\n\n  /**\n   * Process all queued updates by priority\n   */\n  private async flush(): Promise<void> {\n    if (this.isDestroyed) return\n\n    this.isFlushPending = false\n    const startTime = performance.now()\n\n    try {\n      // Process queues in priority order\n      for (const priority of [\n        UpdatePriority.Immediate,\n        UpdatePriority.High,\n        UpdatePriority.Normal,\n        UpdatePriority.Low,\n        UpdatePriority.Idle,\n      ]) {\n        const queue = this.updateQueues.get(priority)\n        if (!queue || queue.size === 0) continue\n\n        const nodesToUpdate = Array.from(queue)\n        queue.clear()\n\n        // Process nodes with error handling\n        for (const node of nodesToUpdate) {\n          try {\n            await this.updateNodeWithRetry(node)\n          } catch (error) {\n            this.handleReactiveError(\n              new ReactiveError(`Failed to update ${node.type} node ${node.id}`, error, node)\n            )\n          }\n        }\n\n        // Allow higher priority updates to interrupt\n        if (this.hasHigherPriorityWork(priority)) {\n          return this.flush()\n        }\n      }\n\n      this.totalUpdateCycles++\n    } finally {\n      const endTime = performance.now()\n      this.totalUpdateTime += endTime - startTime\n    }\n  }\n\n  /**\n   * Update node with retry logic\n   */\n  private async updateNodeWithRetry(node: ReactiveNode, attempt = 1): Promise<void> {\n    try {\n      node.notify()\n    } catch (error) {\n      if (attempt < this.maxRetries) {\n        console.warn(`Reactive update failed, retrying (${attempt}/${this.maxRetries})`)\n        // Exponential backoff\n        await new Promise((resolve) => setTimeout(resolve, attempt * 10))\n        return this.updateNodeWithRetry(node, attempt + 1)\n      } else {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Schedule flush based on priority\n   */\n  private scheduleFlush(priority: UpdatePriority): void {\n    switch (priority) {\n      case UpdatePriority.Immediate:\n        // Synchronous update (use sparingly)\n        void this.flush()\n        break\n      case UpdatePriority.High:\n        // Next microtask for user interactions\n        queueMicrotask(() => this.flush())\n        break\n      case UpdatePriority.Normal:\n        // RequestAnimationFrame for normal updates\n        if (typeof requestAnimationFrame !== 'undefined') {\n          requestAnimationFrame(() => this.flush())\n        } else {\n          queueMicrotask(() => this.flush())\n        }\n        break\n      case UpdatePriority.Low:\n      case UpdatePriority.Idle:\n        // Idle callback for low priority updates\n        if (typeof requestIdleCallback !== 'undefined') {\n          requestIdleCallback(() => this.flush(), { timeout: 1000 })\n        } else {\n          setTimeout(() => this.flush(), 50)\n        }\n        break\n    }\n  }\n\n  /**\n   * Check if there's higher priority work waiting\n   */\n  private hasHigherPriorityWork(currentPriority: UpdatePriority): boolean {\n    for (let priority = UpdatePriority.Immediate; priority < currentPriority; priority++) {\n      const queue = this.updateQueues.get(priority)\n      if (queue && queue.size > 0) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * Get queue for priority level\n   */\n  private getQueue(priority: UpdatePriority): Set<ReactiveNode> {\n    const queue = this.updateQueues.get(priority)\n    if (!queue) {\n      throw new Error(`Invalid priority level: ${priority}`)\n    }\n    return queue\n  }\n\n  /**\n   * Register error handler\n   */\n  onError(handler: (error: ReactiveError) => void): () => void {\n    this.errorHandlers.add(handler)\n    return () => this.errorHandlers.delete(handler)\n  }\n\n  /**\n   * Handle reactive errors with recovery\n   */\n  private handleReactiveError(error: ReactiveError): void {\n    this.errorCount++\n\n    // Notify error handlers\n    let handled = false\n    for (const handler of this.errorHandlers) {\n      try {\n        handler(error)\n        handled = true\n      } catch (handlerError) {\n        console.error('Error handler threw error:', handlerError)\n      }\n    }\n\n    // If no handlers or all handlers failed, log and continue\n    if (!handled) {\n      console.error('Unhandled reactive error:', error)\n      // In development, we might want to throw to surface errors\n      if (process.env.NODE_ENV === 'development') {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Get performance metrics\n   */\n  getPerformanceMetrics(): ReactivePerformanceMetrics {\n    let totalNodes = 0\n    for (const queue of this.updateQueues.values()) {\n      totalNodes += queue.size\n    }\n\n    return {\n      totalNodes,\n      updateCycles: this.totalUpdateCycles,\n      averageUpdateTime:\n        this.totalUpdateCycles > 0 ? this.totalUpdateTime / this.totalUpdateCycles : 0,\n      memoryUsage: this.estimateMemoryUsage(),\n      errorCount: this.errorCount,\n    }\n  }\n\n  /**\n   * Estimate memory usage (rough approximation)\n   */\n  private estimateMemoryUsage(): number {\n    let usage = 0\n    for (const queue of this.updateQueues.values()) {\n      usage += queue.size * 50 // Rough estimate per node\n    }\n    usage += this.errorHandlers.size * 100 // Rough estimate per handler\n    return usage\n  }\n\n  /**\n   * Check if node is scheduled\n   */\n  hasNode(node: ReactiveNode): boolean {\n    for (const queue of this.updateQueues.values()) {\n      if (queue.has(node)) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * Flush all pending updates synchronously\n   */\n  flushSync(): void {\n    if (this.isFlushPending) {\n      this.isFlushPending = false\n      void this.flush()\n    }\n  }\n\n  /**\n   * Clear all pending updates\n   */\n  clearPending(): void {\n    for (const queue of this.updateQueues.values()) {\n      queue.clear()\n    }\n    this.isFlushPending = false\n  }\n\n  /**\n   * Cleanup all reactive nodes and destroy scheduler\n   */\n  destroy(): void {\n    this.isDestroyed = true\n\n    // Cleanup all queued nodes\n    for (const queue of this.updateQueues.values()) {\n      for (const node of queue) {\n        try {\n          node.cleanup()\n        } catch (error) {\n          console.error('Error cleaning up reactive node:', error)\n        }\n      }\n      queue.clear()\n    }\n\n    this.updateQueues.clear()\n    this.errorHandlers.clear()\n    ReactiveScheduler.instance = null\n  }\n\n  /**\n   * Get debug information\n   */\n  getDebugInfo(): object {\n    const queueInfo: Record<string, number> = {}\n    for (const [priority, queue] of this.updateQueues) {\n      queueInfo[UpdatePriority[priority]] = queue.size\n    }\n\n    return {\n      isFlushPending: this.isFlushPending,\n      isDestroyed: this.isDestroyed,\n      queueSizes: queueInfo,\n      errorHandlerCount: this.errorHandlers.size,\n      performance: this.getPerformanceMetrics(),\n    }\n  }\n}\n"],"names":["UpdatePriority","ReactiveError","message","cause","node","_ReactiveScheduler","__publicField","priority","startTime","queue","nodesToUpdate","error","endTime","attempt","resolve","currentPriority","handler","handled","handlerError","totalNodes","usage","queueInfo","ReactiveScheduler"],"mappings":"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"}

package/dist/reactive/unified-scheduler.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Unified Reactive Scheduler v2.0
+ *
+ * Eliminates duplicate update queues and provides enterprise-grade
+ * reactive system with proper error handling and memory management.
+ *
+ * Replaces the existing duplicated queue systems in signal.ts and computed.ts
+ */
+export declare enum UpdatePriority {
+    Immediate = 0,// Synchronous updates (rare)
+    High = 1,// User interaction responses
+    Normal = 2,// Regular updates
+    Low = 3,// Background updates
+    Idle = 4
+}
+export interface ReactiveNode {
+    readonly id: number;
+    readonly type: 'signal' | 'computed' | 'effect';
+    readonly priority: UpdatePriority;
+    notify(): void;
+    cleanup(): void;
+}
+export declare class ReactiveError extends Error {
+    readonly cause: any;
+    readonly node: ReactiveNode;
+    constructor(message: string, cause: any, node: ReactiveNode);
+}
+export interface ReactivePerformanceMetrics {
+    totalNodes: number;
+    updateCycles: number;
+    averageUpdateTime: number;
+    memoryUsage: number;
+    errorCount: number;
+}
+/**
+ * Unified reactive scheduler that replaces all duplicate queue systems
+ */
+export declare class ReactiveScheduler {
+    private static instance;
+    private updateQueues;
+    private isFlushPending;
+    private isDestroyed;
+    private errorHandlers;
+    private readonly maxRetries;
+    private totalUpdateCycles;
+    private totalUpdateTime;
+    private errorCount;
+    private nodeRegistry;
+    private constructor();
+    static getInstance(): ReactiveScheduler;
+    /**
+     * Schedule reactive node for update
+     */
+    schedule(node: ReactiveNode): void;
+    /**
+     * Process all queued updates by priority
+     */
+    private flush;
+    /**
+     * Update node with retry logic
+     */
+    private updateNodeWithRetry;
+    /**
+     * Schedule flush based on priority
+     */
+    private scheduleFlush;
+    /**
+     * Check if there's higher priority work waiting
+     */
+    private hasHigherPriorityWork;
+    /**
+     * Get queue for priority level
+     */
+    private getQueue;
+    /**
+     * Register error handler
+     */
+    onError(handler: (error: ReactiveError) => void): () => void;
+    /**
+     * Handle reactive errors with recovery
+     */
+    private handleReactiveError;
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics(): ReactivePerformanceMetrics;
+    /**
+     * Estimate memory usage (rough approximation)
+     */
+    private estimateMemoryUsage;
+    /**
+     * Check if node is scheduled
+     */
+    hasNode(node: ReactiveNode): boolean;
+    /**
+     * Flush all pending updates synchronously
+     */
+    flushSync(): void;
+    /**
+     * Clear all pending updates
+     */
+    clearPending(): void;
+    /**
+     * Cleanup all reactive nodes and destroy scheduler
+     */
+    destroy(): void;
+    /**
+     * Get debug information
+     */
+    getDebugInfo(): object;
+}
+//# sourceMappingURL=unified-scheduler.d.ts.map

package/dist/reactive/unified-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-scheduler.d.ts","sourceRoot":"","sources":["../../src/reactive/unified-scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oBAAY,cAAc;IACxB,SAAS,IAAI,CAAE,6BAA6B;IAC5C,IAAI,IAAI,CAAE,6BAA6B;IACvC,MAAM,IAAI,CAAE,kBAAkB;IAC9B,GAAG,IAAI,CAAE,qBAAqB;IAC9B,IAAI,IAAI;CACT;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAA;IAC/C,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,MAAM,IAAI,IAAI,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAED,qBAAa,aAAc,SAAQ,KAAK;aAGpB,KAAK,EAAE,GAAG;aACV,IAAI,EAAE,YAAY;gBAFlC,OAAO,EAAE,MAAM,EACC,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,YAAY;CAKrC;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiC;IACxD,OAAO,CAAC,YAAY,CAA+C;IACnE,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,WAAW,CAAQ;IAG3B,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAI;IAG/B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,YAAY,CAA8B;IAElD,OAAO;IASP,MAAM,CAAC,WAAW,IAAI,iBAAiB;IAOvC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAalC;;OAEG;YACW,KAAK;IA6CnB;;OAEG;YACW,mBAAmB;IAejC;;OAEG;IACH,OAAO,CAAC,aAAa;IA8BrB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAQhB;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI;IAK5D;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;OAEG;IACH,qBAAqB,IAAI,0BAA0B;IAgBnD;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IASpC;;OAEG;IACH,SAAS,IAAI,IAAI;IAOjB;;OAEG;IACH,YAAY,IAAI,IAAI;IAOpB;;OAEG;IACH,OAAO,IAAI,IAAI;IAoBf;;OAEG;IACH,YAAY,IAAI,MAAM;CAcvB"}