rask-ui 0.3.4 → 0.4.1

package/dist/component.js

@@ -1,5 +1,6 @@
 import { createComponentVNode, Component, } from "inferno";
 import { getCurrentObserver, Observer, Signal } from "./observation";
+import { syncBatch } from "./batch";
 let currentComponent;
 export function getCurrentComponent() {
     if (!currentComponent) {
@@ -26,6 +27,7 @@ class RaskComponent extends Component {
         this.forceUpdate();
     });
     isRendering = false;
+    effects = [];
     contexts = new Map();
     getChildContext() {
         const parentGetContext = this.context.getContext;
@@ -41,15 +43,36 @@ class RaskComponent extends Component {
     createReactiveProps() {
         const reactiveProps = {};
         const self = this;
+        const signals = new Map();
         for (const prop in this.props) {
-            const signal = new Signal();
-            // @ts-ignore
-            let reactiveValue = this.props[prop];
+            const value = this.props[prop];
+            // Skip known non-reactive props
+            if (typeof value === "function" ||
+                prop === "__component" ||
+                prop === "children" ||
+                prop === "key" ||
+                prop === "ref") {
+                reactiveProps[prop] = value;
+                continue;
+            }
+            // Skip objects/arrays - they're already reactive if they're proxies
+            // No need to wrap them in additional signals
+            if (typeof value === "object" && value !== null) {
+                reactiveProps[prop] = value;
+                continue;
+            }
+            // Only create reactive getters for primitives
             Object.defineProperty(reactiveProps, prop, {
                 get() {
                     if (!self.isRendering) {
                         const observer = getCurrentObserver();
                         if (observer) {
+                            // Lazy create signal only when accessed in reactive context
+                            let signal = signals.get(prop);
+                            if (!signal) {
+                                signal = new Signal();
+                                signals.set(prop, signal);
+                            }
                             observer.subscribeSignal(signal);
                         }
                     }
@@ -57,8 +80,9 @@ class RaskComponent extends Component {
                     return self.props[prop];
                 },
                 set(value) {
-                    if (reactiveValue !== value) {
-                        reactiveValue = value;
+                    // Only notify if signal was created (i.e., prop was accessed reactively)
+                    const signal = signals.get(prop);
+                    if (signal && self.props[prop] !== value) {
                         signal.notify();
                     }
                 },
@@ -72,15 +96,21 @@ class RaskComponent extends Component {
     componentWillUnmount() {
         this.onCleanups.forEach((cb) => cb());
     }
-    componentDidUpdate() {
-        for (const prop in this.props) {
-            if (prop === "__component" || prop === "children") {
-                continue;
+    /**
+     *
+     */
+    componentWillUpdate(nextProps) {
+        syncBatch(() => {
+            for (const prop in nextProps) {
+                if (prop === "__component" || prop === "children") {
+                    continue;
+                }
+                // @ts-ignore
+                this.reactiveProps[prop] = nextProps[prop];
             }
-            // @ts-ignore
-            this.reactiveProps[prop] = this.props[prop];
-        }
+        });
     }
+    componentWillReceiveProps() { }
     shouldComponentUpdate(nextProps) {
         // Shallow comparison of props, excluding internal props
         for (const prop in nextProps) {

package/dist/createComputed.d.ts

@@ -0,0 +1,4 @@
+export declare function createComputed<T extends Record<string, () => any>>(computed: T): {
+    [K in keyof T]: ReturnType<T[K]>;
+};
+//# sourceMappingURL=createComputed.d.ts.map

package/dist/createComputed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createComputed.d.ts","sourceRoot":"","sources":["../src/createComputed.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAChE,QAAQ,EAAE,CAAC,GACV;KACA,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC,CA4CA"}

package/dist/createComputed.js

@@ -0,0 +1,41 @@
+import { getCurrentComponent, onCleanup } from "./component";
+import { getCurrentObserver, Observer, Signal } from "./observation";
+export function createComputed(computed) {
+    let currentComponent;
+    try {
+        currentComponent = getCurrentComponent();
+    }
+    catch {
+        currentComponent = undefined;
+    }
+    const proxy = {};
+    for (const prop in computed) {
+        let isDirty = true;
+        let value;
+        const signal = new Signal();
+        const computedObserver = new Observer(() => {
+            isDirty = true;
+            signal.notify();
+        });
+        if (currentComponent) {
+            onCleanup(() => computedObserver.dispose());
+        }
+        Object.defineProperty(proxy, prop, {
+            get() {
+                const currentObserver = getCurrentObserver();
+                if (currentObserver) {
+                    currentObserver.subscribeSignal(signal);
+                }
+                if (isDirty) {
+                    const stopObserving = computedObserver.observe();
+                    value = computed[prop]();
+                    stopObserving();
+                    isDirty = false;
+                    return value;
+                }
+                return value;
+            },
+        });
+    }
+    return proxy;
+}

package/dist/createEffect.d.ts

@@ -0,0 +1,2 @@
+export declare function createEffect(cb: () => void): void;
+//# sourceMappingURL=createEffect.d.ts.map

package/dist/createEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEffect.d.ts","sourceRoot":"","sources":["../src/createEffect.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,IAAI,QAwB1C"}

package/dist/createEffect.js

@@ -0,0 +1,25 @@
+import { getCurrentComponent, onCleanup } from "./component";
+import { Observer } from "./observation";
+export function createEffect(cb) {
+    let currentComponent;
+    try {
+        currentComponent = getCurrentComponent();
+    }
+    catch {
+        currentComponent = undefined;
+    }
+    const observer = new Observer(() => {
+        // We trigger effects on micro task as synchronous observer notifications
+        // (Like when components sets props) should not synchronously trigger effects
+        queueMicrotask(runEffect);
+    });
+    const runEffect = () => {
+        const stopObserving = observer.observe();
+        cb();
+        stopObserving();
+    };
+    if (currentComponent) {
+        onCleanup(() => observer.dispose());
+    }
+    runEffect();
+}

package/dist/createState.d.ts

@@ -23,4 +23,5 @@
  * @returns A reactive proxy of the state object
  */
 export declare function createState<T extends object>(state: T): T;
+export declare const PROXY_MARKER: unique symbol;
 //# sourceMappingURL=createState.d.ts.map

package/dist/createState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createState.d.ts","sourceRoot":"","sources":["../src/createState.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEzD"}
+{"version":3,"file":"createState.d.ts","sourceRoot":"","sources":["../src/createState.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEzD;AAGD,eAAO,MAAM,YAAY,eAAoB,CAAC"}

package/dist/createState.js

@@ -27,7 +27,7 @@ export function createState(state) {
     return getProxy(state);
 }
 const proxyCache = new WeakMap();
-const PROXY_MARKER = Symbol("isProxy");
+export const PROXY_MARKER = Symbol("isProxy");
 function getProxy(value) {
     // Check if already a proxy to avoid double-wrapping
     if (PROXY_MARKER in value) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { render } from "inferno";
+import { render as infernoRender } from "inferno";
 export { onCleanup, onMount } from "./component";
 export { createContext } from "./createContext";
 export { createState } from "./createState";
@@ -8,4 +8,7 @@ export { createQuery } from "./createQuery";
 export { createMutation } from "./createMutation";
 export { createRef } from "inferno";
 export { createView } from "./createView";
+export { createEffect } from "./createEffect";
+export { createComputed } from "./createComputed";
+export declare function render(...params: Parameters<typeof infernoRender>): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,wBAAgB,MAAM,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,QAMjE"}

package/dist/index.js

@@ -1,4 +1,5 @@
-export { render } from "inferno";
+import { render as infernoRender } from "inferno";
+import { installEventBatching } from "./batch";
 export { onCleanup, onMount } from "./component";
 export { createContext } from "./createContext";
 export { createState } from "./createState";
@@ -8,3 +9,12 @@ export { createQuery } from "./createQuery";
 export { createMutation } from "./createMutation";
 export { createRef } from "inferno";
 export { createView } from "./createView";
+export { createEffect } from "./createEffect";
+export { createComputed } from "./createComputed";
+export function render(...params) {
+    if (!params[1]) {
+        throw new Error("You need a target container");
+    }
+    installEventBatching(params[1]);
+    return infernoRender(...params);
+}

package/dist/observation.d.ts

@@ -1,17 +1,93 @@
-export declare function getCurrentObserver(): Observer;
+/**
+ * ---------------------------------------------------------------------------
+ *  OBSERVER–SIGNAL SYSTEM (OPTIMIZED / LOW MEMORY / ZERO PENDING ARRAYS)
+ * ---------------------------------------------------------------------------
+ *
+ *  STRATEGY OVERVIEW
+ *  -----------------
+ *  Instead of storing subscriber callbacks and disposer closures,
+ *  we model the connection between an Observer and a Signal using a
+ *  lightweight Subscription node.
+ *
+ *  Each Subscription is owned *by both sides*:
+ *    - Signal keeps a doubly-linked list of all Subscriptions.
+ *    - Observer keeps a doubly-linked list of all Subscriptions it has made.
+ *
+ *  This gives several important advantages:
+ *
+ *  ✔ NO per-subscription closures (disposers)
+ *  ✔ NO Set allocations in Signal or Observer
+ *  ✔ NO Array copies during notify()
+ *  ✔ Unsubscribing while iterating is safe (linked-list + cached "next")
+ *  ✔ New subscriptions inside notify() DO NOT fire in the same notify pass
+ *    (using an epoch barrier)
+ *  ✔ Observer.clearSignals() is O(n) with real O(1) unlink
+ *  ✔ Memory overhead is extremely small (one node with 4 pointers)
+ *
+ *  NOTIFY BARRIER
+ *  --------------
+ *  A global integer `epoch` increments for each notify().
+ *  New subscriptions created during notify() store `createdAtEpoch = epoch+1`.
+ *  During traversal, we only fire subscriptions where:
+ *
+ *        sub.createdAtEpoch <= epoch
+ *
+ *  This guarantees consistency and prevents "late" subscribers from firing too early.
+ *
+ * ---------------------------------------------------------------------------
+ */
+export declare function getCurrentObserver(): Observer | undefined;
+/**
+ * A lightweight link connecting ONE observer ↔ ONE signal.
+ * Stored in a linked list on both sides.
+ */
+declare class Subscription {
+    signal: Signal;
+    observer: Observer;
+    prevInSignal: Subscription | null;
+    nextInSignal: Subscription | null;
+    prevInObserver: Subscription | null;
+    nextInObserver: Subscription | null;
+    active: boolean;
+    createdAtEpoch: number;
+    constructor(signal: Signal, observer: Observer, epoch: number);
+}
+/**
+ * SIGNAL — Notifies subscribed observers.
+ */
 export declare class Signal {
-    private subscribers;
-    subscribe(cb: () => void): () => void;
+    private head;
+    private tail;
+    private epoch;
+    /** INTERNAL: Create a subscription from observer → signal. */
+    _subscribe(observer: Observer): Subscription;
+    /** INTERNAL: Unlink a subscription from this signal. */
+    _unsubscribe(sub: Subscription): void;
+    /** Notify all observers.
+     *  Safe even if observers unsubscribe themselves or subscribe new ones mid-run.
+     */
     notify(): void;
 }
+/**
+ * OBSERVER — Reacts to signal changes.
+ * Typically wraps a computation or component.
+ */
 export declare class Observer {
     isDisposed: boolean;
-    private signalDisposers;
-    private clearSignals;
-    private onNotify;
+    private subsHead;
+    private subsTail;
+    private readonly onNotify;
     constructor(onNotify: () => void);
+    /** Called from Signal.notify() */
+    _notify(): void;
+    /** Subscribe this observer to a signal */
     subscribeSignal(signal: Signal): void;
+    /** Remove all signal subscriptions (fast + safe) */
+    private clearSignals;
+    /** Begin dependency collection */
     observe(): () => void;
+    /** Dispose the observer completely */
     dispose(): void;
 }
+export {};
 //# sourceMappingURL=observation.d.ts.map

package/dist/observation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../src/observation.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,aAEjC;AAKD,qBAAa,MAAM;IACjB,OAAO,CAAC,WAAW,CAAyB;IAC5C,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI;IAOxB,MAAM;CAIP;AAED,qBAAa,QAAQ;IACnB,UAAU,UAAS;IACnB,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,QAAQ,CAAa;gBACjB,QAAQ,EAAE,MAAM,IAAI;IAGhC,eAAe,CAAC,MAAM,EAAE,MAAM;IAG9B,OAAO;IAOP,OAAO;CAIR"}
+{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../src/observation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AASH,wBAAgB,kBAAkB,yBAEjC;AAED;;;GAGG;AACH,cAAM,YAAY;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IAGnB,YAAY,EAAE,YAAY,GAAG,IAAI,CAAQ;IACzC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAQ;IAGzC,cAAc,EAAE,YAAY,GAAG,IAAI,CAAQ;IAC3C,cAAc,EAAE,YAAY,GAAG,IAAI,CAAQ;IAG3C,MAAM,UAAQ;IAGd,cAAc,EAAE,MAAM,CAAC;gBAEX,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM;CAK9D;AAED;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,IAAI,CAA6B;IAGzC,OAAO,CAAC,KAAK,CAAK;IAElB,8DAA8D;IAC9D,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY;IAe5C,wDAAwD;IACxD,YAAY,CAAC,GAAG,EAAE,YAAY;IAe9B;;OAEG;IACH,MAAM;CAgBP;AAED;;;GAGG;AACH,qBAAa,QAAQ;IACnB,UAAU,UAAS;IAGnB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,QAAQ,CAA6B;IAG7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;gBAE1B,QAAQ,EAAE,MAAM,IAAI;IAUhC,kCAAkC;IAClC,OAAO;IAMP,0CAA0C;IAC1C,eAAe,CAAC,MAAM,EAAE,MAAM;IAe9B,oDAAoD;IACpD,OAAO,CAAC,YAAY;IAiBpB,kCAAkC;IAClC,OAAO;IAUP,sCAAsC;IACtC,OAAO;CAKR"}

package/dist/observation.js

@@ -1,45 +1,195 @@
+/**
+ * ---------------------------------------------------------------------------
+ *  OBSERVER–SIGNAL SYSTEM (OPTIMIZED / LOW MEMORY / ZERO PENDING ARRAYS)
+ * ---------------------------------------------------------------------------
+ *
+ *  STRATEGY OVERVIEW
+ *  -----------------
+ *  Instead of storing subscriber callbacks and disposer closures,
+ *  we model the connection between an Observer and a Signal using a
+ *  lightweight Subscription node.
+ *
+ *  Each Subscription is owned *by both sides*:
+ *    - Signal keeps a doubly-linked list of all Subscriptions.
+ *    - Observer keeps a doubly-linked list of all Subscriptions it has made.
+ *
+ *  This gives several important advantages:
+ *
+ *  ✔ NO per-subscription closures (disposers)
+ *  ✔ NO Set allocations in Signal or Observer
+ *  ✔ NO Array copies during notify()
+ *  ✔ Unsubscribing while iterating is safe (linked-list + cached "next")
+ *  ✔ New subscriptions inside notify() DO NOT fire in the same notify pass
+ *    (using an epoch barrier)
+ *  ✔ Observer.clearSignals() is O(n) with real O(1) unlink
+ *  ✔ Memory overhead is extremely small (one node with 4 pointers)
+ *
+ *  NOTIFY BARRIER
+ *  --------------
+ *  A global integer `epoch` increments for each notify().
+ *  New subscriptions created during notify() store `createdAtEpoch = epoch+1`.
+ *  During traversal, we only fire subscriptions where:
+ *
+ *        sub.createdAtEpoch <= epoch
+ *
+ *  This guarantees consistency and prevents "late" subscribers from firing too early.
+ *
+ * ---------------------------------------------------------------------------
+ */
+import { queue } from "./batch";
+// GLOBAL OBSERVER STACK (for dependency tracking)
 const observerStack = [];
+let stackTop = -1;
+// Get the active observer during a render/compute
 export function getCurrentObserver() {
-    return observerStack[0];
+    return stackTop >= 0 ? observerStack[stackTop] : undefined;
 }
-let isQueuingNotify = false;
-let notifyQueue = [];
+/**
+ * A lightweight link connecting ONE observer ↔ ONE signal.
+ * Stored in a linked list on both sides.
+ */
+class Subscription {
+    signal;
+    observer;
+    // Linked list pointers within the signal
+    prevInSignal = null;
+    nextInSignal = null;
+    // Linked list pointers within the observer
+    prevInObserver = null;
+    nextInObserver = null;
+    // Whether this subscription is active
+    active = true;
+    // Used for the notify barrier
+    createdAtEpoch;
+    constructor(signal, observer, epoch) {
+        this.signal = signal;
+        this.observer = observer;
+        this.createdAtEpoch = epoch;
+    }
+}
+/**
+ * SIGNAL — Notifies subscribed observers.
+ */
 export class Signal {
-    subscribers = new Set();
-    subscribe(cb) {
-        this.subscribers.add(cb);
-        return () => {
-            this.subscribers.delete(cb);
-        };
+    head = null;
+    tail = null;
+    // Incremented for every notify() call
+    epoch = 0;
+    /** INTERNAL: Create a subscription from observer → signal. */
+    _subscribe(observer) {
+        const sub = new Subscription(this, observer, this.epoch + 1);
+        // Attach to signal's linked list
+        if (this.tail) {
+            this.tail.nextInSignal = sub;
+            sub.prevInSignal = this.tail;
+            this.tail = sub;
+        }
+        else {
+            this.head = this.tail = sub;
+        }
+        return sub;
     }
+    /** INTERNAL: Unlink a subscription from this signal. */
+    _unsubscribe(sub) {
+        if (!sub.active)
+            return;
+        sub.active = false;
+        const { prevInSignal, nextInSignal } = sub;
+        if (prevInSignal)
+            prevInSignal.nextInSignal = nextInSignal;
+        else
+            this.head = nextInSignal;
+        if (nextInSignal)
+            nextInSignal.prevInSignal = prevInSignal;
+        else
+            this.tail = prevInSignal;
+        sub.prevInSignal = sub.nextInSignal = null;
+    }
+    /** Notify all observers.
+     *  Safe even if observers unsubscribe themselves or subscribe new ones mid-run.
+     */
     notify() {
-        const currentSubscribers = Array.from(this.subscribers);
-        currentSubscribers.forEach((cb) => cb());
+        if (!this.head)
+            return;
+        const barrier = ++this.epoch; // new subs won't fire now
+        let sub = this.head;
+        while (sub) {
+            const next = sub.nextInSignal; // cache next → safe if sub unlinks itself
+            if (sub.active && sub.createdAtEpoch <= barrier) {
+                sub.observer._notify();
+            }
+            sub = next;
+        }
     }
 }
+/**
+ * OBSERVER — Reacts to signal changes.
+ * Typically wraps a computation or component.
+ */
 export class Observer {
     isDisposed = false;
-    signalDisposers = new Set();
-    clearSignals() {
-        this.signalDisposers.forEach((dispose) => dispose());
-        this.signalDisposers.clear();
-    }
+    // Doubly-linked list of all subscriptions from this observer
+    subsHead = null;
+    subsTail = null;
+    // Only ONE notify callback closure per observer
     onNotify;
     constructor(onNotify) {
-        this.onNotify = onNotify;
+        const onNotifyQueued = onNotify;
+        onNotifyQueued.__queued = false;
+        this.onNotify = () => {
+            if (onNotifyQueued.__queued)
+                return;
+            queue(onNotify);
+        };
+    }
+    /** Called from Signal.notify() */
+    _notify() {
+        if (!this.isDisposed) {
+            this.onNotify();
+        }
     }
+    /** Subscribe this observer to a signal */
     subscribeSignal(signal) {
-        this.signalDisposers.add(signal.subscribe(this.onNotify));
+        if (this.isDisposed)
+            return;
+        const sub = signal._subscribe(this);
+        // Add to observer's linked list
+        if (this.subsTail) {
+            this.subsTail.nextInObserver = sub;
+            sub.prevInObserver = this.subsTail;
+            this.subsTail = sub;
+        }
+        else {
+            this.subsHead = this.subsTail = sub;
+        }
+    }
+    /** Remove all signal subscriptions (fast + safe) */
+    clearSignals() {
+        let sub = this.subsHead;
+        this.subsHead = this.subsTail = null;
+        while (sub) {
+            const next = sub.nextInObserver;
+            // Unlink from the signal
+            sub.signal._unsubscribe(sub);
+            // Clean up observer-side pointers
+            sub.prevInObserver = sub.nextInObserver = null;
+            sub = next;
+        }
     }
+    /** Begin dependency collection */
     observe() {
         this.clearSignals();
-        observerStack.unshift(this);
+        observerStack[++stackTop] = this;
+        // Return a disposer for this observation frame
         return () => {
-            observerStack.shift();
+            stackTop--;
         };
     }
+    /** Dispose the observer completely */
     dispose() {
-        this.clearSignals();
+        if (this.isDisposed)
+            return;
         this.isDisposed = true;
+        this.clearSignals();
     }
 }

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+interface RaskPluginOptions {
+    include?: RegExp;
+    exclude?: RegExp;
+}
+export declare function raskPlugin(options?: RaskPluginOptions): Plugin;
+export {};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAMnC,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAyDD,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAsPlE"}