@fluixi/reactive 1.0.0-alpha.53

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

@@ -0,0 +1,178 @@
+/**
+ * L2 (core) — the legacy public reactive API re-expressed on top of L0 (graph) +
+ * L1 (runtime), with byte-identical signatures so it is a drop-in for the existing
+ * `createSignal`/`createMemo`/`createEffect`/… surface. This is the "re-point": the
+ * old API delegates to the TC39-shaped core instead of the bespoke Computation graph.
+ *
+ * Scope: the CORE primitives (signals, memos, effects, roots, batch, untrack, on).
+ * The wider surface (resources, stores, context, suspense, transitions, the SSR
+ * eager-stale/drain hooks) is ported separately before the production export flips
+ * — until then this lives behind its own module + spec, validated for behavioural
+ * equivalence against the legacy oracle.
+ *
+ * Timing note: legacy effects flush SYNCHRONOUSLY on a write (outside batch), so we
+ * install a synchronous L1 scheduler here; `batch` still coalesces to one flush.
+ */
+import { State, Computed, untrack as l0untrack } from './core.js';
+import { effect as l1effect, batch as l1batch, setScheduler, afterWrite, flushSync, reportSuspend, getOwner, runWithOwner, } from './runtime.js';
+function isThenable(v) {
+    return !!v && typeof v.then === 'function';
+}
+export { createRoot, onCleanup, getOwner, setOwner, runWithOwner } from './runtime.js';
+// Compat owns all flush points (afterWrite / batch), so the host scheduler is a
+// no-op: enqueue only QUEUES; a write marks the whole graph then flushes once via
+// afterWrite. This separates marking from running (glitch-free, legacy-equivalent
+// synchronous effects) — a synchronous scheduler that flushed mid-propagation would
+// run effects before all observers were marked.
+setScheduler(() => { });
+const $SIGNAL = Symbol.for('signal');
+const $MEMO = Symbol.for('memo');
+// The legacy createSignal attaches a ReactiveNode (with a live `.value`/`.version`)
+// under this symbol; consumers like the store read `signal[$NODE].value` to gate
+// updates. compat exposes a matching node-like view so those consumers work unchanged.
+const $NODE = Symbol.for('signal-node');
+/** createSignal — a writable cell, returned as the legacy `[get, set]` tuple. */
+export 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); // marks the graph dirty
+        afterWrite(); // then flush effects once (no-op inside a batch)
+        return v;
+    });
+    Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+    // Node-like view for consumers (e.g. the store) that read `signal[$NODE].value`.
+    Object.defineProperty(read, $NODE, {
+        value: {
+            get value() {
+                return state.peek();
+            },
+            get version() {
+                return state.version;
+            },
+        },
+        enumerable: false,
+    });
+    return [read, write];
+}
+/** createMemo — a lazy, cached derived value (legacy accessor). */
+export function createMemo(fn, value, options) {
+    let prev = value;
+    // Capture the owner at creation so the memo's fn (and any component it renders, e.g.
+    // a lazy route) runs under THIS scope's owner — preserving context up the owner chain
+    // even when the memo recomputes later (async SSR drain). Matches legacy memo semantics.
+    const owner = getOwner();
+    const c = new Computed(() => runWithOwner(owner, () => {
+        try {
+            return (prev = fn(prev));
+        }
+        catch (e) {
+            // A suspended read (resource/lazy while pending) throws its promise. Legacy
+            // memos keep their previous value and let a Suspense boundary handle it,
+            // rather than rethrowing the promise as an error.
+            if (isThenable(e)) {
+                reportSuspend(e);
+                return prev;
+            }
+            throw e;
+        }
+    }), { equals: options?.equals });
+    const read = (() => c.get());
+    // A memo IS a readable reactive accessor — stamp $SIGNAL (matching the legacy
+    // createMemo) so `isSignal(memo)` is true. Without this, the DOM runtime's
+    // insert() fails to recognise a control-flow memo (For/Switch/Index/Dynamic)
+    // as reactive, caches it as a component, and freezes it → updates never apply.
+    Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+    Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
+    return read;
+}
+/**
+ * createEffect — a re-running side effect. The fn receives the previous return
+ * value and may return a new one (legacy signature) or a cleanup function.
+ */
+export function createEffect(fn, value) {
+    let prev = value;
+    return l1effect(() => {
+        const r = fn(prev);
+        // A function result is treated as the next "prev" (legacy) — unless the fn
+        // never returns one, in which case onCleanup is the cleanup path. We keep the
+        // legacy carry-the-value behaviour; cleanups use onCleanup.
+        prev = r;
+    });
+}
+/**
+ * createComputed — an EAGER, owner-managed reactive computation (returns void).
+ * Unlike a lazy memo it runs immediately and re-runs eagerly when a dep changes;
+ * used for derivations with side effects (e.g. store internals). On L1 that is an
+ * eager effect whose dispose is owned by the current scope.
+ */
+export function createComputed(fn, value) {
+    let prev = value;
+    l1effect(() => {
+        prev = fn(prev);
+    });
+}
+/**
+ * createRenderEffect — an effect that runs in the render phase. For the reactive
+ * core this is an eager effect (the render-vs-commit timing distinction is a DOM-
+ * layer concern); returns a dispose like createEffect.
+ */
+export function createRenderEffect(fn, value) {
+    let prev = value;
+    return l1effect(() => {
+        prev = fn(prev);
+    });
+}
+/** batch — coalesce writes so dependent effects flush once. */
+export function batch(fn) {
+    return l1batch(fn);
+}
+/** untrack — read without subscribing. */
+export function untrack(fn) {
+    return l0untrack(fn);
+}
+/**
+ * startTransition — run `fn`'s updates as one batch. (Minimal port: the concurrent
+ * time-slicing/deferral of the legacy implementation is a later refinement; the
+ * batched-commit semantics that callers rely on are preserved.)
+ */
+export function startTransition(fn) {
+    l1batch(fn);
+    return Promise.resolve();
+}
+/** useTransition — `[isPending, startTransition]`. isPending is synchronous here (no deferral). */
+export function useTransition() {
+    return [() => false, startTransition];
+}
+/** Force any pending effects to run now. */
+export { flushSync };
+/**
+ * flush — drain pending effects, returning a Promise (legacy `flush()` is async; many
+ * callers do `flush().then(...)`). Effects already flush synchronously on each write via
+ * afterWrite, so this just settles any remainder and resolves.
+ */
+export function flush() {
+    flushSync();
+    return Promise.resolve();
+}
+/**
+ * on(deps, fn, { defer }) — an explicit-dependency helper. Reads `deps` (tracked),
+ * then runs `fn(value, prevValue, prevResult)` untracked. `defer` skips the first run.
+ */
+export function on(deps, fn, options) {
+    const isArray = Array.isArray(deps);
+    let prevValue;
+    let defer = options?.defer ?? false;
+    return (prevResult) => {
+        const value = (isArray ? deps.map((d) => d()) : deps());
+        if (defer) {
+            defer = false;
+            prevValue = value;
+            return undefined;
+        }
+        const result = l0untrack(() => fn(value, prevValue, prevResult));
+        prevValue = value;
+        return result;
+    };
+}

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

@@ -0,0 +1 @@
+var E="__fluixi_signal_next_state__",R=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},n=globalThis[E]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:R,onSuspend:null,onError:null};var g=0,k=1,d=2,h=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(n.untracked)return;let t=n.consumer;t&&((this.observers??=new Set).add(t),(t.sources??=new Set).add(this))}},p=class extends h{constructor(t,r){super(),this._value=t,this._equals=r?.equals===!1?()=>!1:r?.equals??Object.is}get(){return this.track(),this._value}set(t){if(!this._equals(this._value,t)){if(this._value=t,this.version++,this.observers)for(let r of[...this.observers])r.markDirty(d);m(this)}}peek(){return this._value}},c=class extends h{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(n.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===d)break}(this.state===d||!this._initialized)&&this.recompute(),this.state=g}recompute(){if(this.sources){for(let l of this.sources)l.observers?.delete(this);this.sources.clear()}let r=n.consumer,o=n.untracked;n.consumer=this,n.untracked=!1;let s,i=!1,u;try{s=this._fn()}catch(l){i=!0,u=l,s=this._value}finally{n.consumer=r,n.untracked=o}let a=!this._initialized||this._threw!==i||(i?u!==this._error:!this._equals(this._value,s));if(this._initialized=!0,this._threw=i,this._error=u,this._value=s,a){if(this.version++,this.observers)for(let l of[...this.observers])l.markDirty(d);m(this)}}markDirty(r){if(this.state>=r)return;let o=this.state===g;if(this.state=r,o){if(this.observers)for(let s of[...this.observers])s.markDirty(k);m(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function m(e){if(e.watchers)for(let t of[...e.watchers])t._notify(e)}var w=class{constructor(t){this._watched=new Set;this._pending=new Set;this._notifyFn=t}watch(...t){for(let r of t)this._watched.add(r),(r.watchers??=new Set).add(this)}unwatch(...t){for(let r of t)this._watched.delete(r),r.watchers?.delete(this),this._pending.delete(r)}getPending(){let t=[...this._pending];return this._pending.clear(),t}_notify(t){if(!this._watched.has(t)||this._pending.has(t))return;let r=this._pending.size===0;this._pending.add(t),r&&this._notifyFn()}};function b(e){if(n.untracked)return e();n.untracked=!0;try{return e()}finally{n.untracked=!1}}function O(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function q(e){return n.onSuspend?(n.onSuspend(e,n.owner),!0):!1}function S(){return n.owner}function N(e){let t=n.owner;return n.owner=e,t}function T(e,t){let r=n.owner;n.owner=e;try{return t()}finally{n.owner=r}}function M(e){n.owner&&(n.owner.cleanups??=[]).push(e)}function v(e){if(e.owned){for(let t=e.owned.length-1;t>=0;t--)v(e.owned[t]);e.owned=null}if(e.cleanups){for(let t=e.cleanups.length-1;t>=0;t--)e.cleanups[t]();e.cleanups=null}}function I(e){let t=O(n.owner);n.owner&&(n.owner.owned??=[]).push(t);let r=n.owner;n.owner=t;try{return e(()=>v(t))}finally{n.owner=r}}function C(e){n.hostSchedule=e??(t=>{Promise.resolve().then(t)})}function W(e){e.queued||(e.queued=!0,n.queue.push(e),!n.scheduled&&n.batchDepth===0&&(n.scheduled=!0,n.hostSchedule(f)))}function f(){if(n.scheduled=!1,n.flushing)return;n.flushing=!0;let e=0;try{for(;n.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let t=n.queue;n.queue=[];for(let r of t)r.queued=!1,r.disposed||r.run()}}finally{n.flushing=!1}}function P(){n.batchDepth===0&&f()}function _(e){n.batchDepth++;try{return e()}finally{--n.batchDepth===0&&f()}}var x=class{constructor(t){this.queued=!1;this.disposed=!1;this.owner=O(n.owner),n.owner&&(n.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new c(()=>{v(this.owner),T(this.owner,()=>{let r=t();typeof r=="function"&&(this.owner.cleanups??=[]).push(r)})}),this.watcher=new w(()=>W(this)),this.run(),this.watcher.watch(this.computed)}run(){if(!this.disposed){this.watcher.getPending();try{this.computed.get()}catch(t){if(t&&typeof t.then=="function"&&n.onSuspend){n.onSuspend(t,this.owner);return}if(n.onError&&n.onError(t,this.owner))return;throw t}}}dispose(){this.disposed||(this.disposed=!0,this.watcher.unwatch(this.computed),v(this.owner))}};function y(e){let t=new x(e);return()=>t.dispose()}function z(e){return!!e&&typeof e.then=="function"}C(()=>{});var D=Symbol.for("signal"),G=Symbol.for("memo"),j=Symbol.for("signal-node");function J(e,t){let r=new p(e,{equals:t?.equals}),o=(()=>r.get()),s=(i=>{let u=typeof i=="function"?i(r.peek()):i;return r.set(u),P(),u});return Object.defineProperty(o,D,{value:!0,enumerable:!0}),Object.defineProperty(o,j,{value:{get value(){return r.peek()},get version(){return r.version}},enumerable:!1}),[o,s]}function Q(e,t,r){let o=t,s=S(),i=new c(()=>T(s,()=>{try{return o=e(o)}catch(a){if(z(a))return q(a),o;throw a}}),{equals:r?.equals}),u=(()=>i.get());return Object.defineProperty(u,D,{value:!0,enumerable:!0}),Object.defineProperty(u,G,{value:!0,enumerable:!0}),u}function X(e,t){let r=t;return y(()=>{r=e(r)})}function Z(e,t){let r=t;y(()=>{r=e(r)})}function ee(e,t){let r=t;return y(()=>{r=e(r)})}function te(e){return _(e)}function ne(e){return b(e)}function V(e){return _(e),Promise.resolve()}function re(){return[()=>!1,V]}function oe(){return f(),Promise.resolve()}function se(e,t,r){let o=Array.isArray(e),s,i=r?.defer??!1;return u=>{let a=o?e.map(A=>A()):e();if(i){i=!1,s=a;return}let l=b(()=>t(a,s,u));return s=a,l}}export{te as batch,Z as createComputed,X as createEffect,Q as createMemo,ee as createRenderEffect,I as createRoot,J as createSignal,oe as flush,f as flushSync,S as getOwner,se as on,M as onCleanup,T as runWithOwner,N as setOwner,V as startTransition,ne as untrack,re as useTransition};

package/dist/lib/signal/graph/core.cjs

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var S=(s,e)=>{for(var t in e)l(s,t,{get:e[t],enumerable:!0})},m=(s,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of T(e))!k.call(s,i)&&i!==t&&l(s,i,{get:()=>e[i],enumerable:!(o=b(e,i))||o.enumerable});return s};var g=s=>m(l({},"__esModule",{value:!0}),s);var D={};S(D,{Computed:()=>f,State:()=>d,Watcher:()=>p,currentComputed:()=>N,hasSinks:()=>E,untrack:()=>C});module.exports=g(D);var q="__fluixi_signal_next_state__",x=s=>{typeof queueMicrotask=="function"?queueMicrotask(s):Promise.resolve().then(s)},r=globalThis[q]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:x,onSuspend:null,onError:null};var _=0,w=1,a=2,h=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(r.untracked)return;let e=r.consumer;e&&((this.observers??=new Set).add(e),(e.sources??=new Set).add(this))}},d=class extends h{constructor(e,t){super(),this._value=e,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){return this.track(),this._value}set(e){if(!this._equals(this._value,e)){if(this._value=e,this.version++,this.observers)for(let t of[...this.observers])t.markDirty(a);v(this)}}peek(){return this._value}},f=class extends h{constructor(t,o){super();this._threw=!1;this._initialized=!1;this.state=a;this.sources=null;this._fn=t,this._equals=o?.equals===!1?()=>!1:o?.equals??Object.is}get(){if(r.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===w&&this.sources){for(let t of this.sources)if(t.updateIfNecessary(),this.state===a)break}(this.state===a||!this._initialized)&&this.recompute(),this.state=_}recompute(){if(this.sources){for(let n of this.sources)n.observers?.delete(this);this.sources.clear()}let t=r.consumer,o=r.untracked;r.consumer=this,r.untracked=!1;let i,u=!1,c;try{i=this._fn()}catch(n){u=!0,c=n,i=this._value}finally{r.consumer=t,r.untracked=o}let y=!this._initialized||this._threw!==u||(u?c!==this._error:!this._equals(this._value,i));if(this._initialized=!0,this._threw=u,this._error=c,this._value=i,y){if(this.version++,this.observers)for(let n of[...this.observers])n.markDirty(a);v(this)}}markDirty(t){if(this.state>=t)return;let o=this.state===_;if(this.state=t,o){if(this.observers)for(let i of[...this.observers])i.markDirty(w);v(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function v(s){if(s.watchers)for(let e of[...s.watchers])e._notify(s)}var p=class{constructor(e){this._watched=new Set;this._pending=new Set;this._notifyFn=e}watch(...e){for(let t of e)this._watched.add(t),(t.watchers??=new Set).add(this)}unwatch(...e){for(let t of e)this._watched.delete(t),t.watchers?.delete(this),this._pending.delete(t)}getPending(){let e=[...this._pending];return this._pending.clear(),e}_notify(e){if(!this._watched.has(e)||this._pending.has(e))return;let t=this._pending.size===0;this._pending.add(e),t&&this._notifyFn()}};function C(s){if(r.untracked)return s();r.untracked=!0;try{return s()}finally{r.untracked=!1}}function N(){return r.consumer}function E(s){return!!(s.observers&&s.observers.size)||!!(s.watchers&&s.watchers.size)}

package/dist/lib/signal/graph/core.d.ts

@@ -0,0 +1,95 @@
+/**
+ * L0 — the TC39-shaped reactive graph core.
+ *
+ * Class-based primitives (`State`, `Computed`, `Watcher`) that own ONLY the
+ * dependency graph: values, versions, source/observer edges, the lazy push-pull
+ * state machine, and glitch-free pull evaluation. They know nothing about
+ * ownership, scheduling, effects, suspense, or resources — those live in the L1
+ * runtime that sits on top (see ../signal.ts). This is a re-shaping of the exact
+ * algorithm the existing graph already runs (CLEAN/CHECK/DIRTY + version + the
+ * `Listener`/observers edges), so behaviour is preserved; it's just relocated
+ * onto classes whose shape matches the TC39 Signals proposal.
+ *
+ * The model is the "push the dirt, pull the value" scheme (Reactively / SolidJS /
+ * the TC39 polyfill): a write PUSHES a maybe-dirty mark down to observers without
+ * recomputing; a read PULLS, settling upstream lazily and recomputing only what
+ * actually changed (equality-gated). Reads outside a tracking scope don't subscribe.
+ */
+declare const CLEAN = 0;
+declare const CHECK = 1;
+declare const DIRTY = 2;
+type NodeState = typeof CLEAN | typeof CHECK | typeof DIRTY;
+/** A thing that can be depended upon: holds observers + a monotonic version. */
+declare abstract class Source {
+    /** Computeds (and watched leaves) that read this node. (was the signalObservers entry) */
+    observers: Set<Computed<any>> | null;
+    /** Watchers eagerly observing this node, for effect scheduling (L1). */
+    watchers: Set<Watcher> | null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    version: number;
+    /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+    updateIfNecessary(): void;
+    /** Link the current consumer (if any) as an observer of this node. */
+    protected track(): void;
+}
+export declare class State<T> extends Source {
+    private _value;
+    private readonly _equals;
+    constructor(value: T, options?: {
+        equals?: ((a: T, b: T) => boolean) | false;
+    });
+    get(): T;
+    set(next: T): void;
+    /** Read without subscribing (peek). */
+    peek(): T;
+}
+export declare class Computed<T> extends Source {
+    private _value;
+    private _error;
+    private _threw;
+    private _initialized;
+    state: NodeState;
+    /** Nodes this computation read on its last run. (was Computation.sources) */
+    sources: Set<Source> | null;
+    private readonly _fn;
+    private readonly _equals;
+    constructor(fn: () => T, options?: {
+        equals?: ((a: T, b: T) => boolean) | false;
+    });
+    get(): T;
+    /** Settle: if CHECK, verify sources; if DIRTY (or never run), recompute. */
+    updateIfNecessary(): void;
+    private recompute;
+    /**
+     * 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: NodeState): void;
+    peek(): T;
+}
+/**
+ * Signal.subtle.Watcher — the only eager observation primitive. Its callback fires
+ * when a watched signal MAY have changed; the callback MUST NOT read or write
+ * signals. Effects (L1) are built on this + a scheduler.
+ */
+export declare class Watcher {
+    private readonly _notifyFn;
+    private readonly _watched;
+    private _pending;
+    constructor(notify: () => void);
+    watch(...nodes: Source[]): void;
+    unwatch(...nodes: Source[]): void;
+    /** Watched nodes that may have changed since the last getPending(). */
+    getPending(): Source[];
+    /** @internal — a watched node became non-clean. Edge-triggered: notify once. */
+    _notify(node: Source): void;
+}
+/** Signal.subtle.untrack — run `fn` without subscribing the current consumer. */
+export declare function untrack<T>(fn: () => T): T;
+/** Signal.subtle.currentComputed — the computed currently evaluating, or null. */
+export declare function currentComputed(): Computed<unknown> | null;
+/** Whether a node currently has observers/watchers (Signal.subtle.hasSinks). */
+export declare function hasSinks(node: Source): boolean;
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/lib/signal/graph/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/core.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,254 @@
+/**
+ * L0 — the TC39-shaped reactive graph core.
+ *
+ * Class-based primitives (`State`, `Computed`, `Watcher`) that own ONLY the
+ * dependency graph: values, versions, source/observer edges, the lazy push-pull
+ * state machine, and glitch-free pull evaluation. They know nothing about
+ * ownership, scheduling, effects, suspense, or resources — those live in the L1
+ * runtime that sits on top (see ../signal.ts). This is a re-shaping of the exact
+ * algorithm the existing graph already runs (CLEAN/CHECK/DIRTY + version + the
+ * `Listener`/observers edges), so behaviour is preserved; it's just relocated
+ * onto classes whose shape matches the TC39 Signals proposal.
+ *
+ * The model is the "push the dirt, pull the value" scheme (Reactively / SolidJS /
+ * the TC39 polyfill): a write PUSHES a maybe-dirty mark down to observers without
+ * recomputing; a read PULLS, settling upstream lazily and recomputing only what
+ * actually changed (equality-gated). Reads outside a tracking scope don't subscribe.
+ */
+import { G } from './state.js';
+// Node states. CHECK = "a source may have changed — verify on read" (your STALE);
+// DIRTY = "definitely recompute"; CLEAN = "cached value is current".
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+// The current consumer + untrack flag live on the shared globalThis-backed state (G)
+// so duplicate module copies share one graph. `consumer`/`untracked` proxy them.
+/** A thing that can be depended upon: holds observers + a monotonic version. */
+class Source {
+    /** Computeds (and watched leaves) that read this node. (was the signalObservers entry) */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    observers = null;
+    /** Watchers eagerly observing this node, for effect scheduling (L1). */
+    watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    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 ??= new Set()).add(consumer);
+        (consumer.sources ??= new Set()).add(this);
+    }
+}
+export class State extends Source {
+    _value;
+    _equals;
+    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++;
+        // Push: direct observers are DIRTY, their transitive observers are CHECK.
+        // Snapshot first — a synchronous scheduler can re-run an effect mid-propagation,
+        // which re-subscribes (mutates `observers`); iterating the live Set would then
+        // re-visit the re-added node forever. (Matches the legacy Array.from(observers).)
+        if (this.observers)
+            for (const o of [...this.observers])
+                o.markDirty(DIRTY);
+        notifyWatchers(this);
+    }
+    /** Read without subscribing (peek). */
+    peek() {
+        return this._value;
+    }
+}
+export class Computed extends Source {
+    _value;
+    _error;
+    _threw = false;
+    _initialized = false;
+    state = DIRTY;
+    /** Nodes this computation read on its last run. (was Computation.sources) */
+    sources = null;
+    _fn;
+    _equals;
+    constructor(fn, options) {
+        super();
+        this._fn = fn;
+        this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+    }
+    get() {
+        // Cycle guard: a computed reading itself.
+        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) {
+            // Pull each source; if one recomputes to a new value it will have flipped
+            // us to DIRTY (markDirty), so stop early.
+            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() {
+        // Drop old edges (we re-collect during the run).
+        if (this.sources) {
+            for (const s of this.sources)
+                s.observers?.delete(this);
+            this.sources.clear();
+        }
+        const prevConsumer = G.consumer;
+        const prevUntracked = G.untracked;
+        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;
+        }
+        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;
+        if (changed) {
+            this.version++;
+            // Our value moved → observers that were merely CHECK must now recompute.
+            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);
+}
+/**
+ * Signal.subtle.Watcher — the only eager observation primitive. Its callback fires
+ * when a watched signal MAY have changed; the callback MUST NOT read or write
+ * signals. Effects (L1) are built on this + a scheduler.
+ */
+export class Watcher {
+    _notifyFn;
+    _watched = new Set();
+    _pending = new Set();
+    constructor(notify) {
+        this._notifyFn = notify;
+    }
+    watch(...nodes) {
+        for (const n of nodes) {
+            this._watched.add(n);
+            (n.watchers ??= 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();
+    }
+}
+/** Signal.subtle.untrack — run `fn` without subscribing the current consumer. */
+export function untrack(fn) {
+    if (G.untracked)
+        return fn();
+    G.untracked = true;
+    try {
+        return fn();
+    }
+    finally {
+        G.untracked = false;
+    }
+}
+/** Signal.subtle.currentComputed — the computed currently evaluating, or null. */
+export function currentComputed() {
+    return G.consumer;
+}
+/** Whether a node currently has observers/watchers (Signal.subtle.hasSinks). */
+export function hasSinks(node) {
+    return !!(node.observers && node.observers.size) || !!(node.watchers && node.watchers.size);
+}

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

@@ -0,0 +1 @@
+var y="__fluixi_signal_next_state__",b=s=>{typeof queueMicrotask=="function"?queueMicrotask(s):Promise.resolve().then(s)},r=globalThis[y]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:b,onSuspend:null,onError:null};var d=0,f=1,a=2,h=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(r.untracked)return;let e=r.consumer;e&&((this.observers??=new Set).add(e),(e.sources??=new Set).add(this))}},v=class extends h{constructor(e,t){super(),this._value=e,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){return this.track(),this._value}set(e){if(!this._equals(this._value,e)){if(this._value=e,this.version++,this.observers)for(let t of[...this.observers])t.markDirty(a);l(this)}}peek(){return this._value}},p=class extends h{constructor(t,i){super();this._threw=!1;this._initialized=!1;this.state=a;this.sources=null;this._fn=t,this._equals=i?.equals===!1?()=>!1:i?.equals??Object.is}get(){if(r.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===f&&this.sources){for(let t of this.sources)if(t.updateIfNecessary(),this.state===a)break}(this.state===a||!this._initialized)&&this.recompute(),this.state=d}recompute(){if(this.sources){for(let n of this.sources)n.observers?.delete(this);this.sources.clear()}let t=r.consumer,i=r.untracked;r.consumer=this,r.untracked=!1;let o,u=!1,c;try{o=this._fn()}catch(n){u=!0,c=n,o=this._value}finally{r.consumer=t,r.untracked=i}let w=!this._initialized||this._threw!==u||(u?c!==this._error:!this._equals(this._value,o));if(this._initialized=!0,this._threw=u,this._error=c,this._value=o,w){if(this.version++,this.observers)for(let n of[...this.observers])n.markDirty(a);l(this)}}markDirty(t){if(this.state>=t)return;let i=this.state===d;if(this.state=t,i){if(this.observers)for(let o of[...this.observers])o.markDirty(f);l(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function l(s){if(s.watchers)for(let e of[...s.watchers])e._notify(s)}var _=class{constructor(e){this._watched=new Set;this._pending=new Set;this._notifyFn=e}watch(...e){for(let t of e)this._watched.add(t),(t.watchers??=new Set).add(this)}unwatch(...e){for(let t of e)this._watched.delete(t),t.watchers?.delete(this),this._pending.delete(t)}getPending(){let e=[...this._pending];return this._pending.clear(),e}_notify(e){if(!this._watched.has(e)||this._pending.has(e))return;let t=this._pending.size===0;this._pending.add(e),t&&this._notifyFn()}};function S(s){if(r.untracked)return s();r.untracked=!0;try{return s()}finally{r.untracked=!1}}function m(){return r.consumer}function g(s){return!!(s.observers&&s.observers.size)||!!(s.watchers&&s.watchers.size)}export{p as Computed,v as State,_ as Watcher,m as currentComputed,g as hasSinks,S as untrack};

package/dist/lib/signal/graph/derived.cjs

@@ -0,0 +1 @@
+"use strict";var w=Object.defineProperty;var D=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var E=(n,e)=>{for(var t in e)w(n,t,{get:e[t],enumerable:!0})},N=(n,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of P(e))!A.call(n,o)&&o!==t&&w(n,o,{get:()=>e[o],enumerable:!(s=D(e,o))||s.enumerable});return n};var R=n=>N(w({},"__esModule",{value:!0}),n);var H={};E(H,{createDebounce:()=>V,createDeferred:()=>L,createSelector:()=>U});module.exports=R(H);var M="__fluixi_signal_next_state__",I=n=>{typeof queueMicrotask=="function"?queueMicrotask(n):Promise.resolve().then(n)},r=globalThis[M]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:I,onSuspend:null,onError:null};var _=0,k=1,c=2,f=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(r.untracked)return;let e=r.consumer;e&&((this.observers??=new Set).add(e),(e.sources??=new Set).add(this))}},p=class extends f{constructor(e,t){super(),this._value=e,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){return this.track(),this._value}set(e){if(!this._equals(this._value,e)){if(this._value=e,this.version++,this.observers)for(let t of[...this.observers])t.markDirty(c);v(this)}}peek(){return this._value}},d=class extends f{constructor(t,s){super();this._threw=!1;this._initialized=!1;this.state=c;this.sources=null;this._fn=t,this._equals=s?.equals===!1?()=>!1:s?.equals??Object.is}get(){if(r.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 t of this.sources)if(t.updateIfNecessary(),this.state===c)break}(this.state===c||!this._initialized)&&this.recompute(),this.state=_}recompute(){if(this.sources){for(let a of this.sources)a.observers?.delete(this);this.sources.clear()}let t=r.consumer,s=r.untracked;r.consumer=this,r.untracked=!1;let o,i=!1,u;try{o=this._fn()}catch(a){i=!0,u=a,o=this._value}finally{r.consumer=t,r.untracked=s}let l=!this._initialized||this._threw!==i||(i?u!==this._error:!this._equals(this._value,o));if(this._initialized=!0,this._threw=i,this._error=u,this._value=o,l){if(this.version++,this.observers)for(let a of[...this.observers])a.markDirty(c);v(this)}}markDirty(t){if(this.state>=t)return;let s=this.state===_;if(this.state=t,s){if(this.observers)for(let o of[...this.observers])o.markDirty(k);v(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function v(n){if(n.watchers)for(let e of[...n.watchers])e._notify(n)}var h=class{constructor(e){this._watched=new Set;this._pending=new Set;this._notifyFn=e}watch(...e){for(let t of e)this._watched.add(t),(t.watchers??=new Set).add(this)}unwatch(...e){for(let t of e)this._watched.delete(t),t.watchers?.delete(this),this._pending.delete(t)}getPending(){let e=[...this._pending];return this._pending.clear(),e}_notify(e){if(!this._watched.has(e)||this._pending.has(e))return;let t=this._pending.size===0;this._pending.add(e),t&&this._notifyFn()}};function j(n){return{cleanups:null,owned:null,parent:n,contexts:null}}function y(n,e){let t=r.owner;r.owner=n;try{return e()}finally{r.owner=t}}function b(n){r.owner&&(r.owner.cleanups??=[]).push(n)}function T(n){if(n.owned){for(let e=n.owned.length-1;e>=0;e--)T(n.owned[e]);n.owned=null}if(n.cleanups){for(let e=n.cleanups.length-1;e>=0;e--)n.cleanups[e]();n.cleanups=null}}function O(n){r.hostSchedule=n??(e=>{Promise.resolve().then(e)})}function W(n){n.queued||(n.queued=!0,r.queue.push(n),!r.scheduled&&r.batchDepth===0&&(r.scheduled=!0,r.hostSchedule(g)))}function g(){if(r.scheduled=!1,r.flushing)return;r.flushing=!0;let n=0;try{for(;r.queue.length;){if(++n>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let e=r.queue;r.queue=[];for(let t of e)t.queued=!1,t.disposed||t.run()}}finally{r.flushing=!1}}function q(){r.batchDepth===0&&g()}var m=class{constructor(e){this.queued=!1;this.disposed=!1;this.owner=j(r.owner),r.owner&&(r.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new d(()=>{T(this.owner),y(this.owner,()=>{let t=e();typeof t=="function"&&(this.owner.cleanups??=[]).push(t)})}),this.watcher=new h(()=>W(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"&&r.onSuspend){r.onSuspend(e,this.owner);return}if(r.onError&&r.onError(e,this.owner))return;throw e}}}dispose(){this.disposed||(this.disposed=!0,this.watcher.unwatch(this.computed),T(this.owner))}};function C(n){let e=new m(n);return()=>e.dispose()}O(()=>{});var G=Symbol.for("signal");var F=Symbol.for("signal-node");function x(n,e){let t=new p(n,{equals:e?.equals}),s=(()=>t.get()),o=(i=>{let u=typeof i=="function"?i(t.peek()):i;return t.set(u),q(),u});return Object.defineProperty(s,G,{value:!0,enumerable:!0}),Object.defineProperty(s,F,{value:{get value(){return t.peek()},get version(){return t.version}},enumerable:!1}),[s,o]}function S(n,e){let t=e;return C(()=>{t=n(t)})}function U(n,e=(t,s)=>t===s){let t=new Map;return S(()=>{let s=n();for(let[o,i]of t){let[u,l]=i,a=e(o,s);u()!==a&&l(a)}}),s=>{let o=t.get(s);if(!o){let[i,u]=x(!1);o=[i,u],t.set(s,o);let l=n();u(e(s,l))}return o[0]()}}function L(n,e){let[t,s]=x(n(),e);return S(()=>{let o=n();e?.timeoutMs?setTimeout(()=>s(()=>o),e.timeoutMs):typeof requestIdleCallback=="function"?requestIdleCallback(()=>s(()=>o)):Promise.resolve().then(()=>s(()=>o))}),t}function V(n,e){let t,s=(...o)=>{t!==void 0&&clearTimeout(t),t=setTimeout(()=>{if(t=void 0,o.length>0){let i=o[o.length-1];typeof i=="object"&&i&&!i.tagName&&i.target&&i.target.tagName&&(i=i.target),i&&typeof i=="object"&&i.tagName&&(i.tagName.toLowerCase()==="input"||i.tagName.toLowerCase()==="textarea")&&i.focus()}n(...o)},e)};return b(()=>{t!==void 0&&clearTimeout(t)}),s}

package/dist/lib/signal/graph/derived.d.ts

@@ -0,0 +1,14 @@
+import type { Accessor, EqualityFn } from '../signal.js';
+/** Keyed selector: `selector(key)` is a fine-grained boolean that flips only when its own key's match changes. */
+export declare function createSelector<T, U = T>(source: () => T, fn?: (key: U, value: T) => boolean): (key: U) => boolean;
+/** A signal that tracks `source` but applies updates on idle/timeout, keeping the current UI responsive. */
+export declare function createDeferred<T>(source: Accessor<T>, options?: {
+    timeoutMs?: number;
+    equals?: false | EqualityFn<T>;
+}): Accessor<T>;
+/**
+ * Debounce wrapper — delays invoking `fn` until `delay` ms after the last call.
+ * Pending timers are cancelled when the owning scope disposes (via onCleanup).
+ */
+export declare function createDebounce<T extends (...args: any[]) => any>(fn: T, delay: number): T;
+//# sourceMappingURL=derived.d.ts.map

package/dist/lib/signal/graph/derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/derived.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAA8B,MAAM,cAAc,CAAC;AAErF,kHAAkH;AAClH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EACrC,MAAM,EAAE,MAAM,CAAC,EACf,EAAE,GAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAA6C,GACtE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAqBrB;AAED,4GAA4G;AAC5G,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA;CAAE,GAC/D,QAAQ,CAAC,CAAC,CAAC,CAUb;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAiCzF"}