@fluixi/reactive 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/signal/utilities.mjs

@@ -1 +1,990 @@
-var $="__fluixi_signal_next_state__",X=n=>{typeof queueMicrotask=="function"?queueMicrotask(n):Promise.resolve().then(n)},i=globalThis[$]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:X,onSuspend:null,onError:null,observer:null};var E="1.0.0-alpha.83";function J(n){return i.observer=n,()=>{i.observer===n&&(i.observer=null)}}var x=[],Q;function f(n){let e=i.observer;e&&e.created(n.parents===void 0?{...n,parents:x,origin:n.origin??Q}:n)}function q(n){return i.observer?(x.push(n),!0):!1}function M(){x.pop()}function B(n){i.observer?.ran?.(n)}function I(n,e){i.observer?.wrote?.(n,e)}function v(n){i.observer?.disposed?.(n)}var Z="__FLUIXI_DEVTOOLS_HOOK__",U=globalThis[Z];if(typeof U?.inject=="function")try{U.inject({observeReactiveNodes:J,version:E})}catch{}function g(){return i.observer!=null}var N=0,K=1,b=2,T=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(i.untracked)return;let e=i.consumer;e&&((this.observers??=new Set).add(e),(e.sources??=new Set).add(this))}},w=class extends T{constructor(e,r){super(),this._value=e,this._equals=r?.equals===!1?()=>!1:r?.equals??Object.is}get(){return this.track(),this._value}set(e){if(!this._equals(this._value,e)){if(this._value=e,this.version++,I(this,i.consumer),this.observers)for(let r of[...this.observers])r.markDirty(b);S(this)}}peek(){return this._value}},p=class extends T{constructor(r,t){super();this._threw=!1;this._initialized=!1;this.state=b;this.sources=null;this._fn=r,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){if(i.consumer===this)throw new Error("Signal.Computed cannot read itself");if(this.track(),this.updateIfNecessary(),this._threw)throw this._error;return this._value}updateIfNecessary(){if(this.state===K&&this.sources){for(let r of this.sources)if(r.updateIfNecessary(),this.state===b)break}(this.state===b||!this._initialized)&&this.recompute(),this.state=N}recompute(){if(this.sources){for(let d of this.sources)d.observers?.delete(this);this.sources.clear()}let r=i.consumer,t=i.untracked,o=q(this);i.consumer=this,i.untracked=!1;let s,u=!1,c;try{s=this._fn()}catch(d){u=!0,c=d,s=this._value}finally{i.consumer=r,i.untracked=t,o&&M()}let l=!this._initialized||this._threw!==u||(u?c!==this._error:!this._equals(this._value,s));if(this._initialized=!0,this._threw=u,this._error=c,this._value=s,B(this),l){if(this.version++,this.observers)for(let d of[...this.observers])d.markDirty(b);S(this)}}markDirty(r){if(this.state>=r)return;let t=this.state===N;if(this.state=r,t){if(this.observers)for(let o of[...this.observers])o.markDirty(K);S(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function S(n){if(n.watchers)for(let e of[...n.watchers])e._notify(n)}var m=class{constructor(e){this._watched=new Set;this._pending=new Set;this._notifyFn=e}watch(...e){for(let r of e)this._watched.add(r),(r.watchers??=new Set).add(this)}unwatch(...e){for(let r of e)this._watched.delete(r),r.watchers?.delete(this),this._pending.delete(r)}getPending(){let e=[...this._pending];return this._pending.clear(),e}_notify(e){if(!this._watched.has(e)||this._pending.has(e))return;let r=this._pending.size===0;this._pending.add(e),r&&this._notifyFn()}};function ee(n){return{cleanups:null,owned:null,parent:n,contexts:null}}function j(n){return i.onSuspend?(i.onSuspend(n,i.owner),!0):!1}function G(){return i.owner}function _(n,e){let r=i.owner;i.owner=n;try{return e()}finally{i.owner=r}}function R(n){if(i.owner){if(i.owner.disposed){n();return}(i.owner.cleanups??=[]).push(n)}}function k(n,e=!0){if(!n.disposed){if(n.owned){for(let r=n.owned.length-1;r>=0;r--)k(n.owned[r]);n.owned=null}if(n.cleanups){for(let r=n.cleanups.length-1;r>=0;r--)n.cleanups[r]();n.cleanups=null}e&&(n.disposed=!0)}}function V(n){i.hostSchedule=n??(e=>{Promise.resolve().then(e)})}function re(n){n.queued||(n.queued=!0,i.queue.push(n),!i.scheduled&&i.batchDepth===0&&(i.scheduled=!0,i.hostSchedule(F)))}function F(){if(i.scheduled=!1,i.flushing)return;i.flushing=!0;let n=0;try{for(;i.queue.length;){if(++n>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let e=i.queue;i.queue=[];for(let r of e)r.queued=!1,r.disposed||r.run()}}finally{i.flushing=!1}}function H(){i.batchDepth===0&&F()}var A=class{constructor(e,r=!1){this.queued=!1;this.disposed=!1;this.owner=ee(i.owner),i.owner&&(i.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new p(()=>{k(this.owner,!1),_(this.owner,()=>{let t=e();typeof t=="function"&&(this.owner.cleanups??=[]).push(t)})}),f({kind:"effect",node:this.computed,handle:this,internal:!r}),this.watcher=new m(()=>re(this)),this.run(),this.watcher.watch(this.computed)}run(){if(!this.disposed){this.watcher.getPending();try{this.computed.get()}catch(e){if(e&&typeof e.then=="function"&&i.onSuspend){i.onSuspend(e,this.owner);return}if(i.onError&&i.onError(e,this.owner))return;throw e}}}dispose(){this.disposed||(this.disposed=!0,v(this.computed),this.watcher.unwatch(this.computed),k(this.owner))}};function L(n,e=!1){let r=new A(n,e);return()=>r.dispose()}function ne(n){return!!n&&typeof n.then=="function"}V(()=>{});var W=Symbol.for("signal"),te=Symbol.for("memo"),oe=Symbol.for("signal-node");function C(n,e){let r=new w(n,{equals:e?.equals}),t=(()=>r.get()),o=(s=>{let u=typeof s=="function"?s(r.peek()):s;return r.set(u),H(),u});return Object.defineProperty(t,W,{value:!0,enumerable:!0}),Object.defineProperty(t,oe,{value:{get value(){return r.peek()},get version(){return r.version}},enumerable:!1}),f({kind:"signal",node:r,handle:t,name:e?.name,set:o}),g()&&R(()=>v(r)),[t,o]}function a(n,e,r){let t=e,o=G(),s=new p(()=>_(o,()=>{try{return t=n(t)}catch(c){if(ne(c))return j(c),t;throw c}}),{equals:r?.equals}),u=(()=>s.get());return Object.defineProperty(u,W,{value:!0,enumerable:!0}),Object.defineProperty(u,te,{value:!0,enumerable:!0}),f({kind:"memo",node:s,handle:u,name:r?.name}),g()&&R(()=>v(s)),u}function z(n,e){let r=e;return L(()=>{r=n(r)},!0)}function D(n){return typeof n=="function"&&!/^class\s/.test(Function.prototype.toString.call(n))}function Y(n){return n==null||Array.isArray(n)||typeof n=="function"||n instanceof Date||n instanceof RegExp||n instanceof Map||n instanceof Set||n instanceof Error?!1:typeof n=="object"}var h=class n{constructor(e){this._closed=!1;this._parentOrParents=null;this._subscriptions=null;e&&(this._subscriptions=[e])}get closed(){return this._closed}unsubscribe(){if(this._closed)return;this._closed=!0;let{_parentOrParents:e,_subscriptions:r}=this;if(e instanceof n)e.remove(this);else if(e!==null)for(let t of e)t.remove(this);if(r){for(let t of r)if(D(t)&&!(t instanceof n))try{t()}catch(o){console.error("Error in unsubscribe function:",o)}else if(Y(t)&&typeof t.unsubscribe=="function")try{t.unsubscribe()}catch(o){console.error("Error unsubscribing child:",o)}this._subscriptions=null}}add(e){if(!e||e===this)return this;if(e.closed)return this;let{_closed:r,_subscriptions:t}=this;if(r){if(D(e))try{e()}catch(o){console.error("Error in unsubscribe function:",o)}else if(e.unsubscribe)try{e.unsubscribe()}catch(o){console.error("Error unsubscribing:",o)}return this}return t||(this._subscriptions=[]),this._subscriptions.push(e),e instanceof n&&e._addParent(this),this}remove(e){let{_subscriptions:r}=this;if(!r)return;let t=r.indexOf(e);t!==-1&&(r.splice(t,1),e._removeParent(this))}_addParent(e){let{_parentOrParents:r}=this;r?Array.isArray(r)?r.push(e):this._parentOrParents=[r,e]:this._parentOrParents=e}_removeParent(e){let{_parentOrParents:r}=this;if(r===e)this._parentOrParents=null;else if(Array.isArray(r)){let t=r.indexOf(e);t!==-1&&(r.splice(t,1),r.length===1&&(this._parentOrParents=r[0]))}}};var y=class extends h{constructor(r,t,o){super();this.isStopped=!1;let s;r?typeof r=="object"?s=r:s={next:r,error:t,complete:o}:s={},this.destination=s}next(r){if(!this.isStopped&&this.destination.next)try{this.destination.next(r)}catch(t){this.error(t)}}error(r){if(!this.isStopped){if(this.isStopped=!0,this.destination.error)try{this.destination.error(r)}catch(t){throw t}else throw r;this.unsubscribe()}}complete(){if(!this.isStopped){if(this.isStopped=!0,this.destination.complete)try{this.destination.complete()}catch(r){this.error(r);return}this.unsubscribe()}}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe())}},P=class extends y{constructor(r,t,o,s){super(r,t,o);this._isUnsubscribing=!1;this._parentSubscriber=null;this._parentSubscriber=s||null}next(r){if(!this.isStopped&&!this._isUnsubscribing)try{super.next(r)}catch(t){this.error(t)}}error(r){if(!this.isStopped&&!this._isUnsubscribing){this._isUnsubscribing=!0;try{super.error(r)}finally{this._isUnsubscribing=!1}}}complete(){if(!this.isStopped&&!this._isUnsubscribing){this._isUnsubscribing=!0;try{super.complete()}finally{this._isUnsubscribing=!1}}}unsubscribe(){this.closed||(this._isUnsubscribing=!0,super.unsubscribe(),this._isUnsubscribing=!1)}};var O=class extends h{constructor(e){if(super(),e)this._subscribe=e;else throw new TypeError("Observable constructor requires a subscribe function")}subscribe(e,r,t){let o;e instanceof y?o=e:o=new P(e,r,t);let{_subscribe:s}=this;try{let u=s.call(this,o);u&&(typeof u=="function"||typeof u.unsubscribe=="function")&&o.add(u)}catch(u){o.error(u)}return o}pipe(...e){return e.length===0?this:e.reduce((r,t)=>t(r),this)}toPromise(){return new Promise((e,r)=>{let t;this.subscribe({next:o=>t=o,error:r,complete:()=>e(t)})})}};function Pe(n,e,r){return a(()=>e(n()),void 0,r)}function Ee(n,e,r){return a(()=>n().filter(e),void 0,r)}function Ue(n,e,r,t){return a(()=>n().reduce(e,r),void 0,t)}function qe(n,e,r){return a(()=>n().find(e),void 0,r)}function Me(n,e,r){return a(()=>n().some(e),void 0,r)}function Be(n,e,r){return a(()=>n().every(e),void 0,r)}function Ie(n,e,r){return a(()=>[...n()].sort(e),void 0,r)}function Ne(n,e){return a(()=>[...new Set(n())],void 0,e)}function Ke(n,e,r){return a(()=>{let t=n.map(o=>o());return e(t)},void 0,r)}function je(...n){return new O(e=>{let r=()=>n.map(o=>typeof o=="function"?o():o.get()),t=n.map(o=>typeof o=="function"&&o.subscribe?o.subscribe(()=>{e.next(r())}):typeof o!="function"?o.subscribe(()=>{e.next(r())}):z(()=>{e.next(r())}));return()=>{t.forEach(o=>{typeof o=="function"?o():o&&typeof o.unsubscribe=="function"&&o.unsubscribe()})}})}function Ge(n,e,r){return a(()=>n()||e(),void 0,r)}function Ve(n,e,r,t){return a(()=>r(n(),e()),void 0,t)}function He(n,e,r){return a(()=>e(n()),void 0,{equals:r,internal:!0})}function Le(n,e,r){return a(()=>{let t=n(),o={};for(let s of e)o[s]=t[s];return o},void 0,r)}function We(n,e,r){return a(()=>{let o={...n()};for(let s of e)delete o[s];return o},void 0,r)}function ze(n,e,r,t){return a(()=>n()?e():r(),void 0,t)}function Ye(n,e,r){return a(()=>n()?e():void 0,void 0,r)}function $e(n,e,r){let[t,o]=C(n()),s;return a(()=>{let u=n();clearTimeout(s),s=setTimeout(()=>o(()=>u),e)}),t}function Xe(n,e,r){let[t,o]=C(n()),s=0,u;return a(()=>{let c=n(),l=Date.now();l-s>=e?(s=l,o(()=>c)):(clearTimeout(u),u=setTimeout(()=>{s=Date.now(),o(()=>c)},e-(l-s)))}),t}function Je(n){let e=n;for(;typeof e=="function";)e=e();return e}export{Ke as combineSignal,je as combineSignals,$e as debounceSignal,Ne as distinctSignal,Be as everySignal,Ee as filterSignal,qe as findSignal,Ye as guardSignal,Pe as mapSignal,Ge as mergeSignal,We as omitSignal,Le as pickSignal,Je as readSignal,Ue as reduceSignal,He as selectSignal,Me as someSignal,Ie as sortSignal,Xe as throttleSignal,ze as whenSignal,Ve as zipSignal};
+/*! @fluixi/reactive v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/signal/graph/core.ts
+var CLEAN = 0;
+var CHECK = 1;
+var DIRTY = 2;
+var Source = class {
+  constructor() {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    this.watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    this.version = 0;
+  }
+  /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+  updateIfNecessary() {
+  }
+  /** Link the current consumer (if any) as an observer of this node. */
+  track() {
+    if (G.untracked) return;
+    const consumer = G.consumer;
+    if (!consumer) return;
+    (this.observers ??= /* @__PURE__ */ new Set()).add(consumer);
+    (consumer.sources ??= /* @__PURE__ */ new Set()).add(this);
+  }
+};
+var State = class extends Source {
+  constructor(value, options) {
+    super();
+    this._value = value;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    this.track();
+    return this._value;
+  }
+  set(next) {
+    if (this._equals(this._value, next)) return;
+    this._value = next;
+    this.version++;
+    reportReactiveWrite(this, G.consumer);
+    if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+    notifyWatchers(this);
+  }
+  /** Read without subscribing (peek). */
+  peek() {
+    return this._value;
+  }
+};
+var Computed = class extends Source {
+  constructor(fn, options) {
+    super();
+    this._threw = false;
+    this._initialized = false;
+    this.state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    this.sources = null;
+    this._fn = fn;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    if (G.consumer === this) {
+      throw new Error("Signal.Computed cannot read itself");
+    }
+    this.track();
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+  /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+  updateIfNecessary() {
+    if (this.state === CHECK) {
+      if (this.sources) {
+        for (const s of this.sources) {
+          s.updateIfNecessary();
+          if (this.state === DIRTY) break;
+        }
+      }
+    }
+    if (this.state === DIRTY || !this._initialized) this.recompute();
+    this.state = CLEAN;
+  }
+  recompute() {
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources.clear();
+    }
+    const prevConsumer = G.consumer;
+    const prevUntracked = G.untracked;
+    const watched = enterReactiveRun(this);
+    G.consumer = this;
+    G.untracked = false;
+    let next;
+    let threw = false;
+    let err;
+    try {
+      next = this._fn();
+    } catch (e) {
+      threw = true;
+      err = e;
+      next = this._value;
+    } finally {
+      G.consumer = prevConsumer;
+      G.untracked = prevUntracked;
+      if (watched) exitReactiveRun();
+    }
+    const changed = !this._initialized || this._threw !== threw || (threw ? err !== this._error : !this._equals(this._value, next));
+    this._initialized = true;
+    this._threw = threw;
+    this._error = err;
+    this._value = next;
+    reportReactiveRun(this);
+    if (changed) {
+      this.version++;
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      notifyWatchers(this);
+    }
+  }
+  /**
+   * Push a maybe-dirty mark. A direct observer of a changed node gets DIRTY; its
+   * own observers get CHECK (recurse), stopping where already marked, so the
+   * push is O(newly-dirtied) and never recomputes.
+   */
+  markDirty(level) {
+    if (this.state >= level) return;
+    const wasClean = this.state === CLEAN;
+    this.state = level;
+    if (wasClean) {
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      notifyWatchers(this);
+    }
+  }
+  peek() {
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+};
+function notifyWatchers(node) {
+  if (!node.watchers) return;
+  for (const w of [...node.watchers]) w._notify(node);
+}
+var Watcher = class {
+  constructor(notify) {
+    this._watched = /* @__PURE__ */ new Set();
+    this._pending = /* @__PURE__ */ new Set();
+    this._notifyFn = notify;
+  }
+  watch(...nodes) {
+    for (const n of nodes) {
+      this._watched.add(n);
+      (n.watchers ??= /* @__PURE__ */ new Set()).add(this);
+    }
+  }
+  unwatch(...nodes) {
+    for (const n of nodes) {
+      this._watched.delete(n);
+      n.watchers?.delete(this);
+      this._pending.delete(n);
+    }
+  }
+  /** Watched nodes that may have changed since the last getPending(). */
+  getPending() {
+    const out = [...this._pending];
+    this._pending.clear();
+    return out;
+  }
+  /** @internal, a watched node became non-clean. Edge-triggered: notify once. */
+  _notify(node) {
+    if (!this._watched.has(node) || this._pending.has(node)) return;
+    const wasEmpty = this._pending.size === 0;
+    this._pending.add(node);
+    if (wasEmpty) this._notifyFn();
+  }
+};
+
+// src/lib/signal/graph/runtime.ts
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function reportSuspend(promise) {
+  if (G.onSuspend) {
+    G.onSuspend(promise, G.owner);
+    return true;
+  }
+  return false;
+}
+function getOwner() {
+  return G.owner;
+}
+function runWithOwner(owner, fn) {
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function onCleanup(fn) {
+  if (!G.owner) return;
+  if (G.owner.disposed) {
+    fn();
+    return;
+  }
+  (G.owner.cleanups ??= []).push(fn);
+}
+function disposeOwner(owner, final = true) {
+  if (owner.disposed) return;
+  if (owner.owned) {
+    for (let i = owner.owned.length - 1; i >= 0; i--) disposeOwner(owner.owned[i]);
+    owner.owned = null;
+  }
+  if (owner.cleanups) {
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) owner.cleanups[i]();
+    owner.cleanups = null;
+  }
+  if (final) owner.disposed = true;
+}
+function setScheduler(fn) {
+  G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
+}
+function enqueue(e) {
+  if (e.queued) return;
+  e.queued = true;
+  G.queue.push(e);
+  if (!G.scheduled && G.batchDepth === 0) {
+    G.scheduled = true;
+    G.hostSchedule(flushSync);
+  }
+}
+function flushSync() {
+  G.scheduled = false;
+  if (G.flushing) return;
+  G.flushing = true;
+  let guard = 0;
+  try {
+    while (G.queue.length) {
+      if (++guard > 1e5) throw new Error("[fluixi] effect flush did not settle (cycle?)");
+      const batchOf = G.queue;
+      G.queue = [];
+      for (const e of batchOf) {
+        e.queued = false;
+        if (!e.disposed) e.run();
+      }
+    }
+  } finally {
+    G.flushing = false;
+  }
+}
+function afterWrite() {
+  if (G.batchDepth === 0) flushSync();
+}
+var EffectNode = class {
+  constructor(fn, report = false) {
+    this.queued = false;
+    this.disposed = false;
+    this.owner = makeOwner(G.owner);
+    if (G.owner) (G.owner.cleanups ??= []).push(() => this.dispose());
+    this.computed = new Computed(() => {
+      disposeOwner(this.owner, false);
+      runWithOwner(this.owner, () => {
+        const r = fn();
+        if (typeof r === "function") (this.owner.cleanups ??= []).push(r);
+      });
+    });
+    reportReactiveNode({ kind: "effect", node: this.computed, handle: this, internal: !report });
+    this.watcher = new Watcher(() => enqueue(this));
+    this.run();
+    this.watcher.watch(this.computed);
+  }
+  run() {
+    if (this.disposed) return;
+    this.watcher.getPending();
+    try {
+      this.computed.get();
+    } catch (e) {
+      if (e && typeof e.then === "function" && G.onSuspend) {
+        G.onSuspend(e, this.owner);
+        return;
+      }
+      if (G.onError && G.onError(e, this.owner)) return;
+      throw e;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    reportReactiveDispose(this.computed);
+    this.watcher.unwatch(this.computed);
+    disposeOwner(this.owner);
+  }
+};
+function effect(fn, report = false) {
+  const node = new EffectNode(fn, report);
+  return () => node.dispose();
+}
+
+// src/lib/signal/graph/compat.ts
+function isThenable(v) {
+  return !!v && typeof v.then === "function";
+}
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+var $MEMO = /* @__PURE__ */ Symbol.for("memo");
+var $NODE = /* @__PURE__ */ Symbol.for("signal-node");
+function createSignal(value, options) {
+  const state = new State(value, { equals: options?.equals });
+  const read = (() => state.get());
+  const write = ((next) => {
+    const v = typeof next === "function" ? next(state.peek()) : next;
+    state.set(v);
+    afterWrite();
+    return v;
+  });
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $NODE, {
+    value: {
+      get value() {
+        return state.peek();
+      },
+      get version() {
+        return state.version;
+      }
+    },
+    enumerable: false
+  });
+  reportReactiveNode({
+    kind: "signal",
+    node: state,
+    handle: read,
+    name: options?.name,
+    set: write
+  });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(state));
+  return [read, write];
+}
+function createMemo(fn, value, options) {
+  let prev = value;
+  const owner = getOwner();
+  const c = new Computed(
+    () => runWithOwner(owner, () => {
+      try {
+        return prev = fn(prev);
+      } catch (e) {
+        if (isThenable(e)) {
+          reportSuspend(e);
+          return prev;
+        }
+        throw e;
+      }
+    }),
+    { equals: options?.equals }
+  );
+  const read = (() => c.get());
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
+  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  return read;
+}
+function createEffect(fn, value) {
+  let prev = value;
+  return effect(() => {
+    const r = fn(prev);
+    prev = r;
+  }, true);
+}
+
+// src/lib/predicates.ts
+function isFunction(value) {
+  return typeof value === "function" && !/^class\s/.test(Function.prototype.toString.call(value));
+}
+function isObject(value) {
+  if (value == null) return false;
+  if (Array.isArray(value)) return false;
+  if (typeof value === "function") return false;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof Error) return false;
+  return typeof value === "object";
+}
+
+// src/lib/observable/subscription.ts
+var Subscription = class _Subscription {
+  /**
+   * Creates a new Subscription.
+   */
+  constructor(unsubscribe) {
+    /** @private */
+    this._closed = false;
+    /** @private */
+    this._parentOrParents = null;
+    /** @private */
+    this._subscriptions = null;
+    if (unsubscribe) {
+      this._subscriptions = [unsubscribe];
+    }
+  }
+  /**
+   * Whether the subscription is closed.
+   */
+  get closed() {
+    return this._closed;
+  }
+  /**
+   * Disposes the resources held by the subscription.
+   * May be called multiple times (idempotent).
+   */
+  unsubscribe() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    const { _parentOrParents, _subscriptions } = this;
+    if (_parentOrParents instanceof _Subscription) {
+      _parentOrParents.remove(this);
+    } else if (_parentOrParents !== null) {
+      for (const parent of _parentOrParents) {
+        parent.remove(this);
+      }
+    }
+    if (_subscriptions) {
+      for (const sub of _subscriptions) {
+        if (isFunction(sub) && !(sub instanceof _Subscription)) {
+          try {
+            sub();
+          } catch (error) {
+            console.error("Error in unsubscribe function:", error);
+          }
+        } else if (isObject(sub) && typeof sub.unsubscribe === "function") {
+          try {
+            sub.unsubscribe();
+          } catch (error) {
+            console.error("Error unsubscribing child:", error);
+          }
+        }
+      }
+      this._subscriptions = null;
+    }
+  }
+  /**
+   * Adds a child subscription or cleanup function to this subscription.
+   * When this subscription is unsubscribed, all added subscriptions/functions will be unsubscribed/called.
+   *
+   * @throws {TypeError} If the argument is not a subscription-like object or function
+   */
+  add(subscription) {
+    if (!subscription || subscription === this) {
+      return this;
+    }
+    if (subscription.closed) {
+      return this;
+    }
+    let { _closed, _subscriptions } = this;
+    if (_closed) {
+      if (isFunction(subscription)) {
+        try {
+          subscription();
+        } catch (error) {
+          console.error("Error in unsubscribe function:", error);
+        }
+      } else if (subscription.unsubscribe) {
+        try {
+          subscription.unsubscribe();
+        } catch (error) {
+          console.error("Error unsubscribing:", error);
+        }
+      }
+      return this;
+    }
+    if (!_subscriptions) {
+      this._subscriptions = [];
+    }
+    this._subscriptions.push(subscription);
+    if (subscription instanceof _Subscription) {
+      subscription._addParent(this);
+    }
+    return this;
+  }
+  /**
+   * Removes a child subscription from this subscription.
+   */
+  remove(subscription) {
+    const { _subscriptions } = this;
+    if (!_subscriptions) {
+      return;
+    }
+    const index = _subscriptions.indexOf(subscription);
+    if (index !== -1) {
+      _subscriptions.splice(index, 1);
+      subscription._removeParent(this);
+    }
+  }
+  /** @private */
+  _addParent(parent) {
+    const { _parentOrParents } = this;
+    if (!_parentOrParents) {
+      this._parentOrParents = parent;
+    } else if (Array.isArray(_parentOrParents)) {
+      _parentOrParents.push(parent);
+    } else {
+      this._parentOrParents = [_parentOrParents, parent];
+    }
+  }
+  /** @private */
+  _removeParent(parent) {
+    const { _parentOrParents } = this;
+    if (_parentOrParents === parent) {
+      this._parentOrParents = null;
+    } else if (Array.isArray(_parentOrParents)) {
+      const index = _parentOrParents.indexOf(parent);
+      if (index !== -1) {
+        _parentOrParents.splice(index, 1);
+        if (_parentOrParents.length === 1) {
+          this._parentOrParents = _parentOrParents[0];
+        }
+      }
+    }
+  }
+};
+
+// src/lib/observable/observable.ts
+var Subscriber = class extends Subscription {
+  /**
+   * Creates a new Subscriber.
+   */
+  constructor(destinationOrNext, error, complete) {
+    super();
+    /** @private */
+    this.isStopped = false;
+    let observer;
+    if (!destinationOrNext) {
+      observer = {};
+    } else if (typeof destinationOrNext === "object") {
+      observer = destinationOrNext;
+    } else {
+      observer = {
+        next: destinationOrNext,
+        error,
+        complete
+      };
+    }
+    this.destination = observer;
+  }
+  /**
+   * Sends the next value to the observer.
+   */
+  next(value) {
+    if (!this.isStopped && this.destination.next) {
+      try {
+        this.destination.next(value);
+      } catch (error) {
+        this.error(error);
+      }
+    }
+  }
+  /**
+   * Sends an error notification to the observer.
+   */
+  error(err) {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      if (this.destination.error) {
+        try {
+          this.destination.error(err);
+        } catch (error) {
+          throw error;
+        }
+      } else {
+        throw err;
+      }
+      this.unsubscribe();
+    }
+  }
+  /**
+   * Sends a complete notification to the observer.
+   */
+  complete() {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      if (this.destination.complete) {
+        try {
+          this.destination.complete();
+        } catch (error) {
+          this.error(error);
+          return;
+        }
+      }
+      this.unsubscribe();
+    }
+  }
+  /**
+   * Unsubscribes the subscriber.
+   */
+  unsubscribe() {
+    if (this.closed) {
+      return;
+    }
+    this.isStopped = true;
+    super.unsubscribe();
+  }
+};
+var SafeSubscriber = class extends Subscriber {
+  constructor(observerOrNext, error, complete, parentSubscriber) {
+    super(observerOrNext, error, complete);
+    /** @private */
+    this._isUnsubscribing = false;
+    /** @private */
+    this._parentSubscriber = null;
+    this._parentSubscriber = parentSubscriber || null;
+  }
+  next(value) {
+    if (!this.isStopped && !this._isUnsubscribing) {
+      try {
+        super.next(value);
+      } catch (error) {
+        this.error(error);
+      }
+    }
+  }
+  error(err) {
+    if (!this.isStopped && !this._isUnsubscribing) {
+      this._isUnsubscribing = true;
+      try {
+        super.error(err);
+      } finally {
+        this._isUnsubscribing = false;
+      }
+    }
+  }
+  complete() {
+    if (!this.isStopped && !this._isUnsubscribing) {
+      this._isUnsubscribing = true;
+      try {
+        super.complete();
+      } finally {
+        this._isUnsubscribing = false;
+      }
+    }
+  }
+  unsubscribe() {
+    if (this.closed) {
+      return;
+    }
+    this._isUnsubscribing = true;
+    super.unsubscribe();
+    this._isUnsubscribing = false;
+  }
+};
+var Observable = class extends Subscription {
+  /**
+   * Creates a new Observable.
+   */
+  constructor(subscribe) {
+    super();
+    if (subscribe) {
+      this._subscribe = subscribe;
+    } else {
+      throw new TypeError("Observable constructor requires a subscribe function");
+    }
+  }
+  subscribe(observerOrNext, error, complete) {
+    let subscriber;
+    if (observerOrNext instanceof Subscriber) {
+      subscriber = observerOrNext;
+    } else {
+      subscriber = new SafeSubscriber(observerOrNext, error, complete);
+    }
+    const { _subscribe } = this;
+    try {
+      const result = _subscribe.call(this, subscriber);
+      if (result) {
+        if (typeof result === "function") {
+          subscriber.add(result);
+        } else if (typeof result.unsubscribe === "function") {
+          subscriber.add(result);
+        }
+      }
+    } catch (err) {
+      subscriber.error(err);
+    }
+    return subscriber;
+  }
+  pipe(...operations) {
+    if (operations.length === 0) {
+      return this;
+    }
+    return operations.reduce(
+      (prev, fn) => fn(prev),
+      this
+    );
+  }
+  /**
+   * Converts the Observable to a Promise.
+   * The Promise resolves with the last emitted value when the Observable completes,
+   * or rejects if the Observable errors.
+   *
+   * @example
+   * // Convert Observable to Promise
+   * const value = await of(1, 2, 3).toPromise();
+   * console.log(value); // 3
+   *
+   * @example
+   * // Handle empty Observable
+   * const value = await EMPTY.toPromise();
+   * console.log(value); // undefined
+   */
+  toPromise() {
+    return new Promise((resolve, reject) => {
+      let lastValue;
+      this.subscribe({
+        next: (value) => lastValue = value,
+        error: reject,
+        complete: () => resolve(lastValue)
+      });
+    });
+  }
+};
+
+// src/lib/signal/utilities.ts
+function mapSignal(signal, fn, options) {
+  return createMemo(() => fn(signal()), void 0, options);
+}
+function filterSignal(signal, predicate, options) {
+  return createMemo(() => signal().filter(predicate), void 0, options);
+}
+function reduceSignal(signal, reducer, initialValue, options) {
+  return createMemo(
+    () => signal().reduce(reducer, initialValue),
+    void 0,
+    options
+  );
+}
+function findSignal(signal, predicate, options) {
+  return createMemo(() => signal().find(predicate), void 0, options);
+}
+function someSignal(signal, predicate, options) {
+  return createMemo(() => signal().some(predicate), void 0, options);
+}
+function everySignal(signal, predicate, options) {
+  return createMemo(() => signal().every(predicate), void 0, options);
+}
+function sortSignal(signal, compareFn, options) {
+  return createMemo(() => [...signal()].sort(compareFn), void 0, options);
+}
+function distinctSignal(signal, options) {
+  return createMemo(() => [...new Set(signal())], void 0, options);
+}
+function combineSignal(signals, combiner, options) {
+  return createMemo(
+    () => {
+      const values = signals.map((s) => s());
+      return combiner(values);
+    },
+    void 0,
+    options
+  );
+}
+function combineSignals(...signals) {
+  return new Observable((observer) => {
+    const getValues = () => signals.map((s) => typeof s === "function" ? s() : s.get());
+    const disposers = signals.map((signal) => {
+      if (typeof signal === "function" && signal.subscribe) {
+        return signal.subscribe(() => {
+          observer.next(getValues());
+        });
+      } else if (typeof signal !== "function") {
+        return signal.subscribe(() => {
+          observer.next(getValues());
+        });
+      }
+      return createEffect(() => {
+        observer.next(getValues());
+      });
+    });
+    return () => {
+      disposers.forEach((dispose) => {
+        if (typeof dispose === "function") dispose();
+        else if (dispose && typeof dispose.unsubscribe === "function") {
+          dispose.unsubscribe();
+        }
+      });
+    };
+  });
+}
+function mergeSignal(primary, fallback, options) {
+  return createMemo(() => primary() || fallback(), void 0, options);
+}
+function zipSignal(a, b, operator, options) {
+  return createMemo(() => operator(a(), b()), void 0, options);
+}
+function selectSignal(signal, selector, equals) {
+  return createMemo(() => selector(signal()), void 0, {
+    equals,
+    internal: true
+  });
+}
+function pickSignal(signal, keys, options) {
+  return createMemo(
+    () => {
+      const obj = signal();
+      const result = {};
+      for (const key of keys) {
+        result[key] = obj[key];
+      }
+      return result;
+    },
+    void 0,
+    options
+  );
+}
+function omitSignal(signal, keys, options) {
+  return createMemo(
+    () => {
+      const obj = signal();
+      const result = { ...obj };
+      for (const key of keys) {
+        delete result[key];
+      }
+      return result;
+    },
+    void 0,
+    options
+  );
+}
+function whenSignal(condition, whenTrue, whenFalse, options) {
+  return createMemo(
+    () => condition() ? whenTrue() : whenFalse(),
+    void 0,
+    options
+  );
+}
+function guardSignal(condition, accessor, options) {
+  return createMemo(
+    () => condition() ? accessor() : void 0,
+    void 0,
+    options
+  );
+}
+function debounceSignal(signal, delay, options) {
+  const [debounced, setDebounced] = createSignal(signal());
+  let timeoutId;
+  createMemo(() => {
+    const value = signal();
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => setDebounced(() => value), delay);
+  });
+  return debounced;
+}
+function throttleSignal(signal, delay, options) {
+  const [throttled, setThrottled] = createSignal(signal());
+  let lastUpdate = 0;
+  let timeoutId;
+  createMemo(() => {
+    const value = signal();
+    const now = Date.now();
+    if (now - lastUpdate >= delay) {
+      lastUpdate = now;
+      setThrottled(() => value);
+    } else {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        lastUpdate = Date.now();
+        setThrottled(() => value);
+      }, delay - (now - lastUpdate));
+    }
+  });
+  return throttled;
+}
+function readSignal(signal) {
+  let value = signal;
+  while (typeof value === "function") value = value();
+  return value;
+}
+export {
+  combineSignal,
+  combineSignals,
+  debounceSignal,
+  distinctSignal,
+  everySignal,
+  filterSignal,
+  findSignal,
+  guardSignal,
+  mapSignal,
+  mergeSignal,
+  omitSignal,
+  pickSignal,
+  readSignal,
+  reduceSignal,
+  selectSignal,
+  someSignal,
+  sortSignal,
+  throttleSignal,
+  whenSignal,
+  zipSignal
+};