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

package/dist/lib/signal/graph/runtime.js

@@ -1,27 +1,32 @@
 /**
- * L1 — the runtime layer the TC39 proposal deliberately OMITS, rebuilt on top of
- * the L0 graph core (./core.ts). TC39 ships only State/Computed/Watcher; everything
- * a framework needs — ownership/disposal, a scheduler, batching, and effects — is
- * left to userland. This module is that userland, expressed once, cleanly:
+ * The runtime layer, on top of the graph core in `core.ts`.
  *
- *   - Owner tree:   createRoot / onCleanup / getOwner / runWithOwner  (no graph entanglement)
- *   - Scheduler:    a microtask-batched effect queue + flushSync / batch
- *   - effect():     re-running side effect built on a Computed + a Watcher + an owner
+ * TC39 ships `State`, `Computed` and `Watcher` and stops there. Everything else a
+ * framework needs is left to userland, and this module is that userland:
  *
- * It is intentionally NOT wired into the package's public exports yet (those names
- * clash with the legacy createEffect/createRoot/onCleanup/batch). It is the staged
- * replacement: once proven, the legacy public API re-points onto this. Effects are
- * built on `Signal.subtle.Watcher` exactly as the proposal intends — the watcher's
- * notify only schedules; the actual re-run (a tracked recompute) happens on flush.
+ *   - Owner tree:   createRoot, onCleanup, getOwner, runWithOwner. No graph edges;
+ *                   ownership is about disposal, not dependency.
+ *   - Scheduler:    an effect queue with flushSync and batch.
+ *   - effect():     a re-running side effect, built from a Computed, a Watcher and
+ *                   an owner.
+ *
+ * This is the live implementation. `@fluixi/reactive/signal` re-exports it through
+ * `signal-next.ts`, and `compat.ts` puts the `create*` names over the top, so the
+ * long-standing public API lands here.
+ *
+ * Effects are built on `Signal.subtle.Watcher` the way the proposal intends: the
+ * watcher's notify only schedules, and the re-run, a tracked recompute, happens on
+ * flush.
  */
 import { Computed, Watcher } from './core.js';
 import { G } from './state.js';
+import { reportReactiveContext, reportReactiveContextCreated, reportReactiveDispose, reportReactiveNode, } from './observe.js';
 /**
  * A child scope of `parent`, attached so the parent's teardown disposes it too.
  *
  * For a derivation that re-runs: context still resolves up the chain from the
  * creation-time owner, while anything registered during a run belongs to this
- * scope and can be torn down before the next one — instead of accumulating on
+ * scope and can be torn down before the next one: instead of accumulating on
  * the enclosing scope and only running when that finally dies.
  */
 export function createChildOwner(parent) {
@@ -33,7 +38,7 @@ export function createChildOwner(parent) {
 /**
  * Tear down a scope's children and cleanups.
  *
- * `final: false` keeps the scope itself alive and reusable — what a re-running
+ * `final: false` keeps the scope itself alive and reusable, what a re-running
  * derivation needs between runs.
  */
 export function disposeScope(owner, final = true) {
@@ -48,16 +53,19 @@ export function isOwnerDisposed(owner) {
 function makeOwner(parent) {
     return { cleanups: null, owned: null, parent, contexts: null };
 }
-export function createContext(defaultValue) {
-    const id = Symbol('context');
+export function createContext(defaultValue, name) {
+    // Named so a watcher can tell two of them apart. Nothing else reads the description.
+    const id = Symbol(name ?? 'context');
+    reportReactiveContextCreated(id);
     const Provider = (props) => {
-        // Stamp the value on a DEDICATED child owner, then read `children` under it — never
+        // Stamp the value on a DEDICATED child owner, then read `children` under it: never
         // on the current owner directly. Two sibling <Ctx.Provider> elements used inline (no
-        // wrapping component) run under the SAME ambient owner, so stamping there lets the
-        // second clobber the first's entry — every descendant then resolves the last value.
+        // wrapping component) run under the same ambient owner, so stamping there lets the
+        // second clobber the first's entry, every descendant then resolves the last value.
         // A child scope isolates each Provider; because createMemo captures the owner at
         // creation, the children memos built while reading `props.children` here capture this
         // scope and resolve the right value even when rendered lazily (Portal/Show/For).
+        reportReactiveContext(id, 'provide', props.value);
         const parent = G.owner;
         const owner = makeOwner(parent);
         (owner.contexts = new Map()).set(id, props.value);
@@ -77,10 +85,14 @@ export function createContext(defaultValue) {
 export function useContext(context) {
     let o = G.owner;
     while (o) {
-        if (o.contexts && o.contexts.has(context.id))
-            return o.contexts.get(context.id);
+        if (o.contexts && o.contexts.has(context.id)) {
+            const found = o.contexts.get(context.id);
+            reportReactiveContext(context.id, 'read', found);
+            return found;
+        }
         o = o.parent;
     }
+    reportReactiveContext(context.id, 'read', context.defaultValue);
     return context.defaultValue;
 }
 /** Read `context` starting from a specific owner chain (not the current scope). */
@@ -108,7 +120,7 @@ export function provide(context, value, fn) {
         G.owner = prev;
     }
 }
-// ── Suspend / error hooks (injected by the boundary layers; L1 stays decoupled) ──
+// ── Suspend / error hooks, injected by the boundary layers so this file stays clear of them ──
 /** Register how a thrown promise (a suspended read) is reported to a boundary. */
 export function setSuspendHandler(fn) {
     G.onSuspend = fn;
@@ -147,9 +159,9 @@ export function runWithOwner(owner, fn) {
 /** Register a teardown for the current owner scope. */
 export function onCleanup(fn) {
     if (!G.owner)
-        return; // no owner → not retained, runs never (matches Solid)
-    // A disposed owner is dead: pushing here would recreate its (nulled) cleanups
-    // array and never run — a leak. Run the teardown immediately instead, so a
+        return; // no owner -> not retained, runs never (matches Solid)
+    // A disposed owner is dead, pushing here would recreate its (nulled) cleanups
+    // array and never run, a leak. Run the teardown immediately instead, so a
     // teardown registered from deferred work (a queued onMount) still fires.
     if (G.owner.disposed) {
         fn();
@@ -157,10 +169,10 @@ export function onCleanup(fn) {
     }
     (G.owner.cleanups ??= []).push(fn);
 }
-// `final` distinguishes a permanent teardown (the scope is gone — mark it disposed so
+// `final` distinguishes a permanent teardown (the scope is gone: mark it disposed so
 // deferred work bails) from an effect's between-runs cleanup (the owner is REUSED for
-// the next run, so it must NOT be marked disposed). Children are always torn down
-// permanently — only the effect's own owner survives a re-run.
+// the next run, so it must not be marked disposed). Children are always torn down
+// permanently, only the effect's own owner survives a re-run.
 function disposeOwner(owner, final = true) {
     if (owner.disposed)
         return;
@@ -191,7 +203,7 @@ export function createRoot(fn) {
         G.owner = prev;
     }
 }
-// ── Scheduler (TC39 has none) — state on G (see ./state.ts) ───────────────────
+// ── Scheduler (TC39 has none): state on G (see ./state.ts) ───────────────────
 export function setScheduler(fn) {
     G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
 }
@@ -233,8 +245,8 @@ export function flushSync() {
     }
 }
 /**
- * Run pending effects after a write completes — but only at the top level (not
- * inside a batch). A single write thus marks the WHOLE graph dirty first, then
+ * Run pending effects after a write completes, but only at the top level (not
+ * inside a batch). A single write thus marks the whole graph dirty first, then
  * flushes once (legacy-equivalent synchronous effects, glitch-free). The `G.flushing`
  * guard makes a write inside an effect a no-op here (the running loop drains it).
  */
@@ -253,16 +265,16 @@ export function batch(fn) {
             flushSync();
     }
 }
-// ── effect() — built on Computed + Watcher + Owner ───────────────────────────
+// ── effect(): built on Computed + Watcher + Owner ───────────────────────────
 class EffectNode {
     computed;
     watcher;
     owner;
     queued = false;
     disposed = false;
-    constructor(fn) {
+    constructor(fn, report = false) {
         this.owner = makeOwner(G.owner);
-        // Tie disposal to the creating scope: when the parent owner tears down it must
+        // Tie disposal to the creating scope, when the parent owner tears down it must
         // fully dispose this effect (unwatch + body cleanups), not just run the body
         // cleanups. Register dispose() as a parent cleanup rather than as an owned tree.
         if (G.owner)
@@ -270,7 +282,7 @@ class EffectNode {
         // The Computed runs the user fn inside a tracking scope + this effect's owner,
         // so reads subscribe and onCleanup/nested roots attach here.
         this.computed = new Computed(() => {
-            // teardown previous run's cleanups before re-running — NOT final: the owner is
+            // teardown previous run's cleanups before re-running. not final: the owner is
             // reused for this run, so it must stay alive (only its children are disposed).
             disposeOwner(this.owner, false);
             runWithOwner(this.owner, () => {
@@ -279,6 +291,10 @@ class EffectNode {
                     (this.owner.cleanups ??= []).push(r);
             });
         });
+        // Before the first run, so a watcher counts that run like every later one. A render
+        // effect is reported too, marked as plumbing: it is not worth drawing, but a node made
+        // inside one has to be able to find its way back to the component that caused it.
+        reportReactiveNode({ kind: 'effect', node: this.computed, handle: this, internal: !report });
         // The watcher only schedules; the recompute happens on flush.
         this.watcher = new Watcher(() => enqueue(this));
         this.run(); // initial synchronous run (Solid semantics)
@@ -309,12 +325,15 @@ class EffectNode {
         if (this.disposed)
             return;
         this.disposed = true;
+        reportReactiveDispose(this.computed);
         this.watcher.unwatch(this.computed);
         disposeOwner(this.owner);
     }
 }
 /** A re-running side effect. Runs once now, then again (G.scheduled) when deps change. */
-export function effect(fn) {
-    const node = new EffectNode(fn);
+export function effect(fn, report = false) {
+    // Reported only when the caller says so. Every DOM binding is a render effect through this
+    // same factory, and a graph holding one node per text node is not a graph anyone reads.
+    const node = new EffectNode(fn, report);
     return () => node.dispose();
 }

package/dist/lib/signal/graph/runtime.mjs

@@ -1 +1,478 @@
-var x="__fluixi_signal_next_state__",m=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},t=globalThis[x]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:m,onSuspend:null,onError:null};var y=0,T=1,d=2,p=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(t.untracked)return;let n=t.consumer;n&&((this.observers??=new Set).add(n),(n.sources??=new Set).add(this))}};var c=class extends p{constructor(r,o){super();this._threw=!1;this._initialized=!1;this.state=d;this.sources=null;this._fn=r,this._equals=o?.equals===!1?()=>!1:o?.equals??Object.is}get(){if(t.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===T&&this.sources){for(let r of this.sources)if(r.updateIfNecessary(),this.state===d)break}(this.state===d||!this._initialized)&&this.recompute(),this.state=y}recompute(){if(this.sources){for(let u of this.sources)u.observers?.delete(this);this.sources.clear()}let r=t.consumer,o=t.untracked;t.consumer=this,t.untracked=!1;let s,i=!1,f;try{s=this._fn()}catch(u){i=!0,f=u,s=this._value}finally{t.consumer=r,t.untracked=o}let b=!this._initialized||this._threw!==i||(i?f!==this._error:!this._equals(this._value,s));if(this._initialized=!0,this._threw=i,this._error=f,this._value=s,b){if(this.version++,this.observers)for(let u of[...this.observers])u.markDirty(d);_(this)}}markDirty(r){if(this.state>=r)return;let o=this.state===y;if(this.state=r,o){if(this.observers)for(let s of[...this.observers])s.markDirty(T);_(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function _(e){if(e.watchers)for(let n of[...e.watchers])n._notify(e)}var h=class{constructor(n){this._watched=new Set;this._pending=new Set;this._notifyFn=n}watch(...n){for(let r of n)this._watched.add(r),(r.watchers??=new Set).add(this)}unwatch(...n){for(let r of n)this._watched.delete(r),r.watchers?.delete(this),this._pending.delete(r)}getPending(){let n=[...this._pending];return this._pending.clear(),n}_notify(n){if(!this._watched.has(n)||this._pending.has(n))return;let r=this._pending.size===0;this._pending.add(n),r&&this._notifyFn()}};function D(e){let n=l(e);return e&&(e.owned??=[]).push(n),n}function N(e,n=!0){a(e,n)}function P(e){return!!e&&e.disposed===!0}function l(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function z(e){let n=Symbol("context");return{id:n,defaultValue:e,Provider:o=>{let s=t.owner,i=l(s);(i.contexts=new Map).set(n,o.value),s&&(s.owned??=[]).push(i),t.owner=i;try{return o.children}finally{t.owner=s}}}}function I(e){let n=t.owner;for(;n;){if(n.contexts&&n.contexts.has(e.id))return n.contexts.get(e.id);n=n.parent}return e.defaultValue}function G(e,n){let r=e;for(;r;){if(r.contexts&&r.contexts.has(n.id))return r.contexts.get(n.id);r=r.parent}return n.defaultValue}function R(e,n,r){let o=l(t.owner);(o.contexts=new Map).set(e.id,n),t.owner&&(t.owner.owned??=[]).push(o);let s=t.owner;t.owner=o;try{return r()}finally{t.owner=s}}function M(e){t.onSuspend=e}function W(e){return t.onSuspend?(t.onSuspend(e,t.owner),!0):!1}function A(e){t.onError=e}function F(){return t.owner}function H(e){let n=t.owner;return t.owner=e,n}function S(e,n){let r=t.owner;t.owner=e;try{return n()}finally{t.owner=r}}function V(e){if(t.owner){if(t.owner.disposed){e();return}(t.owner.cleanups??=[]).push(e)}}function a(e,n=!0){if(!e.disposed){if(e.owned){for(let r=e.owned.length-1;r>=0;r--)a(e.owned[r]);e.owned=null}if(e.cleanups){for(let r=e.cleanups.length-1;r>=0;r--)e.cleanups[r]();e.cleanups=null}n&&(e.disposed=!0)}}function K(e){let n=l(t.owner);t.owner&&(t.owner.owned??=[]).push(n);let r=t.owner;t.owner=n;try{return e(()=>a(n))}finally{t.owner=r}}function Y(e){t.hostSchedule=e??(n=>{Promise.resolve().then(n)})}function k(e){e.queued||(e.queued=!0,t.queue.push(e),!t.scheduled&&t.batchDepth===0&&(t.scheduled=!0,t.hostSchedule(v)))}function v(){if(t.scheduled=!1,t.flushing)return;t.flushing=!0;let e=0;try{for(;t.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let n=t.queue;t.queue=[];for(let r of n)r.queued=!1,r.disposed||r.run()}}finally{t.flushing=!1}}function j(){t.batchDepth===0&&v()}function L(e){t.batchDepth++;try{return e()}finally{--t.batchDepth===0&&v()}}var w=class{constructor(n){this.queued=!1;this.disposed=!1;this.owner=l(t.owner),t.owner&&(t.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new c(()=>{a(this.owner,!1),S(this.owner,()=>{let r=n();typeof r=="function"&&(this.owner.cleanups??=[]).push(r)})}),this.watcher=new h(()=>k(this)),this.run(),this.watcher.watch(this.computed)}run(){if(!this.disposed){this.watcher.getPending();try{this.computed.get()}catch(n){if(n&&typeof n.then=="function"&&t.onSuspend){t.onSuspend(n,this.owner);return}if(t.onError&&t.onError(n,this.owner))return;throw n}}}dispose(){this.disposed||(this.disposed=!0,this.watcher.unwatch(this.computed),a(this.owner))}};function U(e){let n=new w(e);return()=>n.dispose()}export{j as afterWrite,L as batch,D as createChildOwner,z as createContext,K as createRoot,N as disposeScope,U as effect,v as flushSync,F as getOwner,P as isOwnerDisposed,V as onCleanup,R as provide,G as readContextFrom,W as reportSuspend,S as runWithOwner,A as setErrorHandler,H as setOwner,Y as setScheduler,M as setSuspendHandler,I as useContext};
+// 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 reportReactiveContextCreated(id) {
+  G.observer?.contextCreated?.(id);
+}
+function reportReactiveContext(id, kind, value) {
+  const observer = G.observer;
+  if (!observer?.context || !running.length) return;
+  observer.context(running[running.length - 1], id, kind, value);
+}
+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 {
+  }
+}
+
+// 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 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 createChildOwner(parent) {
+  const owner = makeOwner(parent);
+  if (parent) (parent.owned ??= []).push(owner);
+  return owner;
+}
+function disposeScope(owner, final = true) {
+  disposeOwner(owner, final);
+}
+function isOwnerDisposed(owner) {
+  return !!owner && owner.disposed === true;
+}
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function createContext(defaultValue, name) {
+  const id = Symbol(name ?? "context");
+  reportReactiveContextCreated(id);
+  const Provider = (props) => {
+    reportReactiveContext(id, "provide", props.value);
+    const parent = G.owner;
+    const owner = makeOwner(parent);
+    (owner.contexts = /* @__PURE__ */ new Map()).set(id, props.value);
+    if (parent) (parent.owned ??= []).push(owner);
+    G.owner = owner;
+    try {
+      return props.children;
+    } finally {
+      G.owner = parent;
+    }
+  };
+  return { id, defaultValue, Provider };
+}
+function useContext(context) {
+  let o = G.owner;
+  while (o) {
+    if (o.contexts && o.contexts.has(context.id)) {
+      const found = o.contexts.get(context.id);
+      reportReactiveContext(context.id, "read", found);
+      return found;
+    }
+    o = o.parent;
+  }
+  reportReactiveContext(context.id, "read", context.defaultValue);
+  return context.defaultValue;
+}
+function readContextFrom(owner, context) {
+  let o = owner;
+  while (o) {
+    if (o.contexts && o.contexts.has(context.id)) return o.contexts.get(context.id);
+    o = o.parent;
+  }
+  return context.defaultValue;
+}
+function provide(context, value, fn) {
+  const owner = makeOwner(G.owner);
+  (owner.contexts = /* @__PURE__ */ new Map()).set(context.id, value);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function setSuspendHandler(fn) {
+  G.onSuspend = fn;
+}
+function reportSuspend(promise) {
+  if (G.onSuspend) {
+    G.onSuspend(promise, G.owner);
+    return true;
+  }
+  return false;
+}
+function setErrorHandler(fn) {
+  G.onError = fn;
+}
+function getOwner() {
+  return G.owner;
+}
+function setOwner(owner) {
+  const prev = G.owner;
+  G.owner = owner;
+  return prev;
+}
+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 createRoot(fn) {
+  const owner = makeOwner(G.owner);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn(() => disposeOwner(owner));
+  } finally {
+    G.owner = prev;
+  }
+}
+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();
+}
+function batch(fn) {
+  G.batchDepth++;
+  try {
+    return fn();
+  } finally {
+    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();
+}
+export {
+  afterWrite,
+  batch,
+  createChildOwner,
+  createContext,
+  createRoot,
+  disposeScope,
+  effect,
+  flushSync,
+  getOwner,
+  isOwnerDisposed,
+  onCleanup,
+  provide,
+  readContextFrom,
+  reportSuspend,
+  runWithOwner,
+  setErrorHandler,
+  setOwner,
+  setScheduler,
+  setSuspendHandler,
+  useContext
+};