@solidjs/signals 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/prod/store/storePath.js

@@ -0,0 +1,103 @@
+import { isWrappable, ownEnumerableKeys } from "./store.js";
+
+const DELETE = Symbol(0);
+
+function isPrototypePollutionKey(t) {
+    return t === "__proto__" || t === "constructor" || t === "prototype";
+}
+
+function updatePath(t, e, o = 0) {
+    let r, n = t;
+    if (o < e.length - 1) {
+        r = e[o];
+        const i = typeof r;
+        const f = Array.isArray(t);
+        if (i === "string" && isPrototypePollutionKey(r)) return;
+        if (Array.isArray(r)) {
+            for (let n = 0; n < r.length; n++) {
+                e[o] = r[n];
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "function") {
+            for (let n = 0; n < t.length; n++) {
+                if (r(t[n], n)) {
+                    e[o] = n;
+                    updatePath(t, e, o);
+                }
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "object") {
+            const {from: n = 0, to: i = t.length - 1, by: f = 1} = r;
+            for (let r = n; r <= i; r += f) {
+                e[o] = r;
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (o < e.length - 2) {
+            updatePath(t[r], e, o + 1);
+            return;
+        }
+        n = t[r];
+    }
+    let i = e[e.length - 1];
+    if (typeof i === "function") {
+        i = i(n);
+        if (i === n) return;
+    }
+    if (r === undefined && i == undefined) return;
+    if (i === DELETE) {
+        delete t[r];
+    } else if (r === undefined || isWrappable(n) && isWrappable(i) && !Array.isArray(i)) {
+        const e = r !== undefined ? t[r] : t;
+        const o = ownEnumerableKeys(i);
+        for (let t = 0; t < o.length; t++) {
+            const r = o[t];
+            if (typeof r === "string" && isPrototypePollutionKey(r)) continue;
+            const n = Object.getOwnPropertyDescriptor(i, r);
+            if (n.get || n.set) Object.defineProperty(e, r, n); else e[r] = n.value;
+        }
+    } else {
+        t[r] = i;
+    }
+}
+
+/**
+ * Path-based setter helper for `createStore`. Call `storePath(...path, value)`
+ * to produce a draft-mutating function suitable for passing to `setStore`.
+ *
+ * The canonical setter form in Solid 2.0 is the draft-mutating callback
+ * (`setStore(s => { s.user.name = "Ada"; })`). `storePath` is a backwards-
+ * compatibility helper for users porting from Solid 1.x's
+ * `setStore("user", "name", "Ada")` style — it's optional and you can mix the
+ * two styles freely.
+ *
+ * Path parts can be:
+ * - a single key — `"user"`, `0`
+ * - an array of keys — `[0, 1, 2]`
+ * - a range over an array — `{ from?, to?, by? }`
+ * - a filter `(item, index) => boolean` for arrays
+ *
+ * The final argument is the new value or an updater `(prev) => next`. Use
+ * `storePath.DELETE` to remove a property.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * setState(storePath("user", "name", "Grace"));
+ * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
+ * setState(storePath("user", "nickname", storePath.DELETE));
+ * ```
+ */ const storePath = /* @__PURE__ */ Object.assign(function storePath(...t) {
+    return e => {
+        updatePath(e, t);
+    };
+}, {
+    DELETE: DELETE
+});
+
+export { storePath };

package/dist/prod/store/utils.js

@@ -0,0 +1,297 @@
+import { pendingCheckActive } from "../core/core.js";
+
+import { SUPPORTS_PROXY } from "../core/constants.js";
+
+import "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { createMemo } from "../signals.js";
+
+import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getKeys, getPropertyDescriptor, $TRACK } from "./store.js";
+
+function snapshotImpl(e, t, r, n) {
+    let o, s, c, i, f, u;
+    if (!isWrappable(e)) return e;
+    if (r && r.has(e)) return r.get(e);
+    if (!r) r = new Map;
+    if (o = e[$TARGET] || n?.get(e)?.[$TARGET]) {
+        if (t) {
+            trackSelf(o, $TRACK);
+            // A tracked walk reads THROUGH the record without touching the proxy
+            // traps — witness the record's affects() channel like a trap read would.
+                        if (pendingCheckActive) witnessAffectsMark(o);
+        }
+        c = mergedOverlay(o);
+        s = Array.isArray(o[STORE_VALUE]);
+        r.set(e, c ? i = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
+        e = o[STORE_VALUE];
+        n = o[STORE_LOOKUP] ?? storeLookup;
+    } else {
+        s = Array.isArray(e);
+        r.set(e, e);
+    }
+    if (s) {
+        const s = c?.length ?? e.length;
+        for (let p = 0; p < s; p++) {
+            u = c && p in c ? c[p] : e[p];
+            if (u === $DELETED) continue;
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== u || i) {
+                if (!i) r.set(e, i = [ ...e ]);
+                i[p] = f;
+            }
+        }
+        // Deleted trailing slots are skipped above, so restore length to preserve
+        // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
+                if (i) i.length = s;
+    } else if (!c) {
+        // Specialized walk for the common no-overlay case (from #2756): the own
+        // descriptor gives the value directly, so each property is read once with
+        // no overlay membership checks.
+        const s = getKeys(e, undefined);
+        for (let c = 0, p = s.length; c < p; c++) {
+            const p = s[c];
+            const l = Object.getOwnPropertyDescriptor(e, p);
+            if (l.get) continue;
+            u = l.value;
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== u || i) {
+                if (!i) {
+                    i = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(i, e);
+                }
+                i[p] = f;
+            }
+        }
+    } else {
+        const s = getKeys(e, c);
+        for (let p = 0, l = s.length; p < l; p++) {
+            let l = s[p];
+            const a = getPropertyDescriptor(e, c, l);
+            if (a.get) continue;
+            u = l in c ? c[l] : e[l];
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || i) {
+                if (!i) {
+                    i = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(i, e);
+                }
+                i[l] = f;
+            }
+        }
+    }
+    return i || e;
+}
+
+function snapshot(e, t, r) {
+    return snapshotImpl(e, false, t, r);
+}
+
+/**
+ * Returns a plain (non-proxy) deep copy **and** subscribes the current
+ * tracking scope to every nested change in the source store. Any write
+ * anywhere in the subtree invalidates the consumer.
+ *
+ * Use this when you need plain data inside a reactive scope and want to
+ * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
+ * memo that should rerun on any nested change). For most read paths, prefer
+ * direct property access — Solid stores already track per-property reads
+ * with no `deep()` wrapper needed.
+ *
+ * @example
+ * ```ts
+ * const [state] = createStore({ a: { b: { c: 1 } } });
+ *
+ * createEffect(
+ *   () => deep(state),                  // reruns on any nested change
+ *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
+ * );
+ * ```
+ */ function deep(e) {
+    return snapshotImpl(e, true);
+}
+
+function trueFn() {
+    return true;
+}
+
+const propTraps = {
+    get(e, t, r) {
+        if (t === $PROXY) return r;
+        return e.get(t);
+    },
+    has(e, t) {
+        if (t === $PROXY) return true;
+        return e.has(t);
+    },
+    set: trueFn,
+    deleteProperty: trueFn,
+    getOwnPropertyDescriptor(e, t) {
+        return {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return e.get(t);
+            },
+            set: trueFn,
+            deleteProperty: trueFn
+        };
+    },
+    ownKeys(e) {
+        return e.keys();
+    }
+};
+
+function resolveSource(e) {
+    return !(e = typeof e === "function" ? e() : e) ? {} : e;
+}
+
+const $SOURCES = Symbol(0);
+
+/**
+ * Merges multiple props-like objects into a single proxy that *preserves
+ * reactivity*. Reads are forwarded to the right-most source that defines the
+ * property, so later sources override earlier ones (like `Object.assign`).
+ *
+ * Function arguments are treated as memo-backed sources — useful for passing
+ * derived defaults whose computation should track reactively.
+ *
+ * Use this in component bodies to merge defaults / overrides without losing
+ * Solid's per-property tracking.
+ *
+ * @example
+ * ```tsx
+ * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
+ *   const props = merge({ type: "button", disabled: false }, _props);
+ *
+ *   return <button type={props.type} disabled={props.disabled}>{props.label}</button>;
+ * }
+ * ```
+ */ function merge(...e) {
+    if (e.length === 1 && typeof e[0] !== "function") return e[0];
+    let t = false;
+    const r = [];
+    for (let n = 0; n < e.length; n++) {
+        const o = e[n];
+        t = t || !!o && $PROXY in o;
+        const s = !!o && o[$SOURCES];
+        if (s) {
+            for (let e = 0; e < s.length; e++) r.push(s[e]);
+        } else r.push(typeof o === "function" ? (t = true, createMemo(o)) : o);
+    }
+    if (SUPPORTS_PROXY && t) {
+        return new Proxy({
+            get(e) {
+                if (e === $SOURCES) return r;
+                for (let t = r.length - 1; t >= 0; t--) {
+                    const n = resolveSource(r[t]);
+                    if (e in n) return n[e];
+                }
+            },
+            has(e) {
+                for (let t = r.length - 1; t >= 0; t--) {
+                    if (e in resolveSource(r[t])) return true;
+                }
+                return false;
+            },
+            keys() {
+                const e = new Set;
+                for (let t = 0; t < r.length; t++) {
+                    const n = ownEnumerableKeys(resolveSource(r[t]));
+                    for (let t = 0; t < n.length; t++) e.add(n[t]);
+                }
+                return [ ...e ];
+            }
+        }, propTraps);
+    }
+    const n = Object.create(null);
+    let o = false;
+    let s = r.length - 1;
+    for (let e = s; e >= 0; e--) {
+        const t = r[e];
+        if (!t) {
+            e === s && s--;
+            continue;
+        }
+        const c = Object.getOwnPropertyNames(t);
+        for (let r = c.length - 1; r >= 0; r--) {
+            const i = c[r];
+            if (i === "__proto__" || i === "constructor") continue;
+            if (!n[i]) {
+                o = o || e !== s;
+                const r = Object.getOwnPropertyDescriptor(t, i);
+                n[i] = r.get ? {
+                    enumerable: true,
+                    configurable: true,
+                    get: r.get.bind(t)
+                } : r;
+            }
+        }
+    }
+    if (!o) return r[s];
+    const c = {};
+    const i = Object.keys(n);
+    for (let e = i.length - 1; e >= 0; e--) {
+        const t = i[e], r = n[t];
+        if (r.get) Object.defineProperty(c, t, r); else c[t] = r.value;
+    }
+    c[$SOURCES] = r;
+    return c;
+}
+
+/**
+ * Returns a reactive proxy of `props` with the listed keys hidden. Tracking
+ * on the remaining keys is preserved.
+ *
+ * Use it to forward "rest" props to a child element while pulling out the
+ * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
+ *
+ * @example
+ * ```tsx
+ * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
+ *   const rest = omit(props, "label", "value", "onInput");
+ *
+ *   return (
+ *     <label>
+ *       {props.label}
+ *       <input
+ *         {...rest}
+ *         value={props.value}
+ *         onInput={e => props.onInput(e.currentTarget.value)}
+ *       />
+ *     </label>
+ *   );
+ * }
+ * ```
+ */ function omit(e, ...t) {
+    if (SUPPORTS_PROXY && $PROXY in e) {
+        return new Proxy({
+            get(r) {
+                return t.includes(r) ? undefined : e[r];
+            },
+            has(r) {
+                return !t.includes(r) && r in e;
+            },
+            keys() {
+                return ownEnumerableKeys(e).filter(e => !t.includes(e));
+            }
+        }, propTraps);
+    }
+    const r = {};
+    const n = Object.getOwnPropertyNames(e);
+    const o = t.length > 4 && n.length > t.length ? new Set(t) : undefined;
+    for (const s of n) {
+        if (o ? !o.has(s) : !t.includes(s)) {
+            const t = Object.getOwnPropertyDescriptor(e, s);
+            !t.get && !t.set && t.enumerable && t.writable && t.configurable ? r[s] = t.value : Object.defineProperty(r, s, t);
+        }
+    }
+    return r;
+}
+
+export { deep, merge, omit, snapshot };

package/dist/types/affects.d.ts

@@ -0,0 +1,47 @@
+import type { Accessor } from "./signals.js";
+import { type Store } from "./store/store.js";
+/**
+ * Declares that in-flight work will change the targeted data: the named
+ * slot(s) — and everything DERIVED from them — read as pending
+ * (`isPending` → `true`) from the declaration until the surrounding
+ * transaction settles or reverts. Marks ride the same status rails as real
+ * in-flight async, so pendingness flows through memos and effects like any
+ * other pending source, while the marked values themselves stay readable
+ * (a mark is a promise of change, not an absence of value). This is the
+ * declaration verb of the pending model — additive only. A mark can turn
+ * pending ON for data the graph can't see changing yet; nothing can turn
+ * pending OFF while a real change is in flight — a quiet `refresh()`
+ * re-ask under a mark still reads pending (declaring the reload is what
+ * makes it a real question).
+ *
+ * Targets:
+ * - `affects(store)` — a store proxy (any record, root or nested): every
+ *   record reachable from it at declaration time reads pending, including
+ *   through captured child proxies (e.g. `<For>` rows). Siblings are
+ *   untouched; records added after the declaration are not covered.
+ * - `affects(record, key)` — exactly the named slot of the record. One key
+ *   per call (keys do NOT form a path — target the owning record directly).
+ * - `affects(accessor)` — a source accessor (signal or memo): the source
+ *   reads pending.
+ *
+ * Typically called at the top of an `action` alongside optimistic writes —
+ * both are up-front declarations about the same mutation. Outside any
+ * transaction the mark is released at the end of the current flush.
+ *
+ * @example
+ * ```ts
+ * const send = action(function* (text: string) {
+ *   setState(s => { s.messages.push({ text, status: "sending" }); });
+ *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
+ *   yield api.send(text);
+ * });
+ *
+ * const reload = action(function* () {
+ *   affects(thing);      // the whole store pends…
+ *   refresh(thing);      // …over this otherwise-quiet re-ask
+ *   yield api.done();
+ * });
+ * ```
+ */
+export declare function affects(target: Accessor<unknown> | Store<object>): void;
+export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

package/dist/types/boundaries.d.ts

@@ -20,18 +20,18 @@ export declare class RevealController {
     _evaluating: boolean;
     constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    isReady(): boolean;
+    _isReady(): boolean;
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
      * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: fully ready (atomic).
+     * - `together`: every direct slot is minimally ready.
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
      */
-    isMinimallyReady(): boolean;
-    register(slot: RevealSlot): void;
-    unregister(slot: RevealSlot): void;
-    evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
+    _isMinimallyReady(): boolean;
+    _register(slot: RevealSlot): void;
+    _unregister(slot: RevealSlot): void;
+    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
 }
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
@@ -48,7 +48,7 @@ export declare class CollectionQueue extends Queue {
     constructor(type: number);
     run(type: number): void;
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    checkSources(): void;
+    _checkSources(): void;
 }
 /**
  * Lower-level primitive that backs the `<Loading>` flow control. Catches
@@ -128,7 +128,7 @@ export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error:
  *   own minimal signal).
  * - `together` — every direct slot is minimally ready.
  * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites when fully ready, since natural treats composites as atomic).
+ *   composites via their own minimal signal).
  *
  * @example
  * ```ts

package/dist/types/core/async.d.ts

@@ -1,6 +1,9 @@
 import { type OptimisticLane } from "./lanes.js";
-import type { Computed } from "./types.js";
-export declare function settlePendingSource(el: Computed<any>): void;
+import type { Computed, Link } from "./types.js";
+export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
+export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
+export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>, snap?: boolean): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;

package/dist/types/core/constants.d.ts

@@ -10,6 +10,14 @@ export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
 export declare const REACTIVE_MANUAL_WRITE: number;
+/**
+ * The pending recompute is a re-ask of the same question: `refresh()` dirtied
+ * the node while no tracked input changed value. Cleared whenever a real
+ * value-change notification arrives (`insertSubs`), and consumed by
+ * `recompute` into the node's `_reask` classification — a quiet (re-ask)
+ * pending window does not read as pending (question-scoped pending model).
+ */
+export declare const REACTIVE_REASK: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;

package/dist/types/core/core.d.ts

@@ -5,6 +5,12 @@ export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBI
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE: string;
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
 export declare let tracking: boolean;
+/** @internal verdict-module glue */
+export declare function setPendingCheckActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setLatestReadActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setContextInternal(v: Owner | null): void;
 export declare let stale: boolean;
 export declare let pendingCheckActive: boolean;
 export declare let latestReadActive: boolean;
@@ -60,6 +66,12 @@ export declare function setStrictRead(v: string | false): string | false;
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
+ * an isPending() probe (`refresh`) additionally pulls the node fully up to
+ * date so its status flags reflect the current graph.
+ */
+export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -97,76 +109,7 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
  * ```
  */
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
-/**
- * Keep the lazily-created isPending()/latest() companion nodes in sync with a
- * new value. Every path that produces a value for `el` — direct set, async
- * resolution, transition-held sync recompute — must route through here so a
- * new write path can't silently skip the companions (#2831).
- */
-export declare function syncCompanions<T>(el: Signal<T> | Computed<T>, value: T): void;
-/**
- * Update _pendingSignal when pending state changes. When the override clears
- * (pending -> not pending), merge the sub-lane into the source's lane so
- * isPending effects are blocked until the full scope resolves.
- */
-export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
-/**
- * A firewall's status change re-derives the verdicts of its probed leaves:
- * leaf companions consult the firewall (broad inheritance), so async
- * starting/settling on the firewall must poke them or they keep a stale
- * verdict forever (V4 stuck-companion class, #2838).
- */
-export declare function updateChildCompanions(el: Computed<any>): void;
-/**
- * Settlement checkpoint (#2838): re-derive a node's companions directly from
- * its committed state. Called when the transition machinery for the node is
- * done with it — a pending commit or an optimistic revert. Verdicts are
- * written committed (not through setSignal) because a transition-scoped
- * override window opened here would itself need a settlement, re-scheduling
- * forever while async is still in flight. This is what keeps companions
- * coherent past transition completion: a verdict is a property of the data
- * (A19), so it must survive the transition that happened to produce it.
- */
-export declare function snapCompanionsToState(owner: Signal<any> | Computed<any>): void;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
-/**
- * Reads reactive expressions while bypassing any pending async overlay — i.e.
- * always returns the most-recently-committed value, even when newer reads
- * inside `fn` are still in flight.
- *
- * Useful inside a `<Loading>` boundary's children when you want to keep
- * showing the previous resolved data instead of the fallback while the next
- * value loads.
- *
- * @example
- * ```tsx
- * <Loading fallback={<Skeleton />}>
- *   {/* During a transition, render the previous user instead of skeleton: *\/}
- *   <UserCard user={latest(() => user())} />
- * </Loading>
- * ```
- */
-export declare function latest<T>(fn: () => T): T;
-/**
- * Returns `true` if any reactive read inside `fn` is showing a stale value
- * while newer async work is pending. Does not subscribe — pair with a tracked
- * memo if you want to react to pending status changes.
- *
- * Useful for showing inline transition indicators alongside the previous
- * value (rather than swapping to a `<Loading>` fallback).
- * Because `fn` is read normally, `isPending` participates in Loading/SSR
- * readiness the same way the read itself would.
- *
- * @example
- * ```tsx
- * const pending = createMemo(() => isPending(() => user()));
- *
- * <button disabled={pending()}>{pending() ? "Saving…" : "Save"}</button>
- *
- * <button disabled={isPending(() => user())}>Save</button>
- * ```
- */
-export declare function isPending(fn: () => any): boolean;
 /**
  * Invalidates one reactive source, forcing it to re-execute even if its inputs
  * haven't changed.

package/dist/types/core/dev.d.ts

@@ -6,7 +6,7 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error";
 export interface DiagnosticEvent {
     sequence: number;

package/dist/types/core/external.d.ts

@@ -11,35 +11,5 @@ export declare let externalSourceConfig: {
     factory: ExternalSourceFactory;
     untrack: <T>(fn: () => T) => T;
 } | null;
-/**
- * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
- * into Solid's tracking graph. Every computation will be wrapped so that the
- * external library can track its own dependencies alongside Solid's.
- *
- * Multiple calls pipe together: each new factory wraps the previous one.
- *
- * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
- *   call trigger when external deps change. Return `{ track, dispose }`.
- * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
- *
- * @example
- * ```ts
- * // Bridge an external "subscribe / notify" library into Solid's graph.
- * // `factory` wraps every Solid compute so the external library can attach
- * // its own dependency tracker; `trigger` re-runs the compute on external
- * // change. `untrack` mirrors Solid's `untrack()` into the external library
- * // so that reads inside `untrack(...)` don't get tracked twice.
- * enableExternalSource({
- *   factory: (compute, trigger) => {
- *     const sub = externalLib.subscribe(trigger);
- *     return {
- *       track: prev => externalLib.run(() => compute(prev)),
- *       dispose: () => sub.unsubscribe()
- *     };
- *   },
- *   untrack: fn => externalLib.untracked(fn)
- * });
- * ```
- */
 export declare function enableExternalSource(config: ExternalSourceConfig): void;
 export declare function _resetExternalSourceConfig(): void;

package/dist/types/core/heap.d.ts

@@ -1,4 +1,12 @@
 import type { Computed } from "./types.js";
+/** The queue a node belongs to, picked from its own zombie flag. */
+export declare function queueFor(n: Computed<any>): Heap;
+/**
+ * Schedule one subscriber to re-run on the next flush: tracked effects bypass
+ * the heap and go directly to their effect queue; everything else is inserted
+ * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ */
+export declare function enqueueSub(node: Computed<any>): void;
 export interface Heap {
     _heap: (Computed<unknown> | undefined)[];
     _marked: boolean;