@warp-ts/reactivity 0.0.0-stage → 0.1.2

package/dist/types/core.js

@@ -0,0 +1,714 @@
+// @warp-ts/reactivity · REQ-LFE-001-R · Signal / Computed / Effect / batch / owner（设计 01-R §2 ~ §5、§7）
+import { CLEAN, CHECK, DIRTY, isComputation } from './types';
+import { err, warn } from './error';
+// ---- 全局上下文（模块级，单实例）----
+let Listener = null;
+let Owner_ = null;
+let Updates = null;
+let BatchDepth = 0;
+let Pending = false;
+let Flushing = false;
+let Clock = 0;
+let NextId = 0;
+let Seq = 0;
+/** FD-43：失去最后一个订阅者的 computed，flush 尾部退订上游（对齐 Vue 3.5：computed 不归 owner）*/
+let Orphans = null;
+/** FD-48：flush 中首个未处理错误，整轮跑完后再抛 */
+let Failed = false, FailErr;
+/** dev：顶层 root 登记，供依赖图快照 */
+const allRoots = __DEV__ ? new Set() : null;
+/** dev：flush 尾部回调（DevTools 探针的唯一插桩点，REQ-LFE-003 RB-301） */
+const flushCbs = __DEV__ ? new Set() : null;
+/**
+ * REQ-LFE-002 ADR-205 / RB-202 · 服务端模式：无 DOM 则无需订阅，也不能让订阅跨请求存活。
+ * 开启后 `effect / renderEffect` **同步求值一次即返回、不建订阅**；
+ * `signal / computed / owner` 语义不变（computed 仍惰性可缓存）。由 `@warp-ts/server` 在进程启动时开启。
+ *
+ * `batch / flushSync` **不加分支**（03 §1 要求「空转」，但那是结果不是手段）：serverMode 下
+ * 没有任何非纯 computation 会进 `Updates`，两者本来就什么都不做，多写两个 `if` 只是白给
+ * 客户端产物字节（NFR-002）。
+ */
+let ServerMode = false;
+const NOOP = () => { };
+function eqOf(o) {
+    if (!o || o.equals === undefined)
+        return Object.is;
+    if (o.equals === false)
+        return () => false;
+    return o.equals;
+}
+// ---- R-01 signal ----
+export function signal(v, opts) {
+    const n = { _v: v, _eq: eqOf(opts), _subs: null, _subSlots: null };
+    if (__DEV__) {
+        n._name = opts?.name;
+        n._id = ++NextId;
+    }
+    const read = (() => readSignal(n));
+    read.set = x => writeSignal(n, typeof x === 'function' ? x(n._v) : x);
+    read.peek = () => n._v;
+    return read;
+}
+function readSignal(n) {
+    const l = Listener;
+    if (l) {
+        // R-M5：单源 / 单订阅者不建数组；第二个出现时升级为数组
+        let lSlot;
+        const ls = l._sources;
+        if (ls === null) {
+            l._sources = n;
+            lSlot = 0;
+        }
+        else if (!Array.isArray(ls)) {
+            l._sources = [ls, n];
+            l._sourceSlots = [l._sourceSlots, 0];
+            lSlot = 1;
+        }
+        else {
+            ls.push(n);
+            l._sourceSlots.push(0);
+            lSlot = ls.length - 1;
+        }
+        let sSlot;
+        const ns = n._subs;
+        if (ns === null || ns === undefined) {
+            n._subs = l;
+            n._subSlots = lSlot;
+            sSlot = 0;
+        }
+        else if (!Array.isArray(ns)) {
+            n._subs = [ns, l];
+            n._subSlots = [n._subSlots, lSlot];
+            sSlot = 1;
+        }
+        else {
+            ns.push(l);
+            n._subSlots.push(lSlot);
+            sSlot = ns.length - 1;
+        }
+        if (Array.isArray(l._sourceSlots))
+            l._sourceSlots[lSlot] = sSlot;
+        else
+            l._sourceSlots = sSlot;
+    }
+    return n._v;
+}
+function writeSignal(n, v) {
+    // E-2（REQ-LFE-008 M-00 / 设计 006-00 §2.5）：R103「写 computed」整体收进 `__DEV__` —— prod 下
+    // 该分支与 `isComputation` 判定一起被 DCE（−28 B），写 computed 静默无效（设计 01-R：仅 dev 抛错）。
+    if (__DEV__ && isComputation(n))
+        throw err('WARP-R103', n._name);
+    if (__DEV__ && Listener && Listener._pure && Listener._running)
+        warn('WARP-R104', Listener._name);
+    if (n._eq(n._v, v))
+        return;
+    n._v = v;
+    ++Clock;
+    if (n._subs)
+        runUpdates(() => eachSub(n._subs, c => markDirty(c, DIRTY)));
+}
+/** 遍历订阅者（单值或数组）；遍历期间不修改集合 */
+function eachSub(subs, fn) {
+    if (!subs)
+        return;
+    if (Array.isArray(subs)) {
+        for (let i = 0; i < subs.length; i++)
+            fn(subs[i]);
+    }
+    else
+        fn(subs);
+}
+/** 非 computed 的 signal 节点被外部（reactive）触发 */
+export function _notify(n) {
+    ++Clock;
+    if (n._subs)
+        runUpdates(() => eachSub(n._subs, c => markDirty(c, DIRTY)));
+}
+export const _track = readSignal;
+export function _mkSignalNode() { return { _v: undefined, _eq: () => false, _subs: null, _subSlots: null }; }
+export function _hasListener() { return Listener !== null; }
+/** 内部：轻量信号（runtime-dom 行 item / index 用）：只有节点 + 一个读闭包，写入走 _write，省去 set / peek 闭包（内存专项 M-1） */
+export function _lightSignal(v) {
+    const node = { _v: v, _eq: Object.is, _subs: null, _subSlots: null };
+    if (__DEV__)
+        node._id = ++NextId;
+    return { read: () => readSignal(node), node };
+}
+export const _write = writeSignal;
+// ---- R-02 / R-03 调度（push-pull）----
+function markDirty(c, state) {
+    if (c._state >= state)
+        return;
+    const was = c._state;
+    c._state = state;
+    if (was === CLEAN && !c._pure)
+        Updates.push(c);
+    eachSub(c._subs, s => markDirty(s, CHECK));
+}
+function readComputed(c) {
+    if (c._running)
+        throw err('WARP-R102', __DEV__ ? `computed "${c._name || '(anonymous)'}" 在自身求值期间被读取` : '');
+    if (c._state !== CLEAN && !(c._seen === Clock && !Listener))
+        updateIfNecessary(c);
+    if (!Listener && !c._subs && c._sources)
+        orphan(c); // FD-43：非追踪读取且无订阅者 → flush 尾部退订上游
+    return readSignal(c);
+}
+function updateIfNecessary(c) {
+    if (c._disposed)
+        return;
+    if (c._state === CHECK) {
+        const src = c._sources;
+        const check = (s) => { if (isComputation(s)) {
+            updateIfNecessary(s);
+            if (s._updatedAt > c._updatedAt) {
+                c._state = DIRTY;
+                return true;
+            }
+        } return false; };
+        if (src) {
+            if (Array.isArray(src)) {
+                for (let i = 0; i < src.length; i++)
+                    if (check(src[i]))
+                        break;
+            }
+            else
+                check(src);
+        }
+        if (c._state === CHECK)
+            c._state = CLEAN;
+    }
+    if (c._state === DIRTY)
+        runComputation(c);
+}
+function runComputation(c) {
+    cleanNode(c);
+    c._state = CLEAN; // 执行前置 CLEAN：运行期间写入自身依赖 → 重新标脏并入队（Solid 语义，DC-23）
+    const pL = Listener, pO = Owner_, pR = RunningC;
+    Listener = c;
+    Owner_ = c._pure ? c._parent : c;
+    RunningC = c;
+    c._running = true;
+    try {
+        const nv = c._fn(ON_CLEANUP); // R-M6：共享注册函数，不再每次运行分配闭包
+        if (c._pure && (!c._updatedAt || !c._eq(c._v, nv))) {
+            c._v = nv;
+            c._updatedAt = ++Clock;
+            eachSub(c._subs, s => markDirty(s, DIRTY));
+        }
+        else if (!c._pure)
+            c._updatedAt = Clock;
+    }
+    catch (e) {
+        handleError(c, e);
+    }
+    finally {
+        c._running = false;
+        Listener = pL;
+        Owner_ = pO;
+        RunningC = pR;
+    }
+}
+let RunningC = null;
+/**
+ * dev 诊断（prod 整体 DCE）：`WARP-R101` 无 owner；
+ * `WARP-R105`（RDC-33 / 006 L-23）computed 内创建 effect / createRoot —— computed 必须是纯函数，
+ * 重算不会释放它们（行为不改，只出告警；设计 01-R §7 已登记为设计约束）
+ */
+function devPure() {
+    if (RunningC && RunningC._pure && RunningC._running)
+        warn('WARP-R105', RunningC._name);
+}
+function devNewOwner(n) {
+    if (!Owner_)
+        warn('WARP-R101', n);
+    devPure();
+}
+const ON_CLEANUP = (f) => { const c = RunningC; if (c)
+    (c._cleanups || (c._cleanups = [])).push(f);
+else if (__DEV__)
+    warn('WARP-R101', 'onCleanup(fn 参数) 仅在计算同步运行期内有效（MEM-02）'); };
+function handleError(from, e) {
+    let o = from;
+    while (o) {
+        if (o._err && o._err(e) !== false)
+            return;
+        o = o._parent;
+    }
+    throw e;
+}
+function runUpdates(fn) {
+    if (Updates)
+        return fn();
+    Updates = [];
+    try {
+        return fn();
+    }
+    finally {
+        if (BatchDepth === 0)
+            scheduleFlush();
+    }
+}
+function scheduleFlush() {
+    if (Pending)
+        return;
+    Pending = true;
+    queueMicrotask(flush);
+}
+const bySeq = (a, b) => a._seq - b._seq;
+/** 跑完当前队列（含本轮新入队）：FD-38 每轮按创建序执行（守卫先于其内容）；FD-48 单项抛错不中断 */
+function drain() {
+    let q = Updates;
+    Updates = [];
+    let round = 0;
+    while (q && q.length) {
+        if (__DEV__ && ++round > 100)
+            throw err('WARP-R102', 'flush 超过 100 轮，疑似 effect 互写');
+        q.sort(bySeq);
+        for (let i = 0; i < q.length; i++) {
+            const c = q[i];
+            if (c._state !== CLEAN)
+                try {
+                    updateIfNecessary(c);
+                }
+                catch (e) {
+                    if (!Failed) {
+                        Failed = true;
+                        FailErr = e;
+                    }
+                }
+        }
+        q = Updates;
+        Updates = [];
+    }
+}
+/** 仍无订阅者的孤儿 computed：退订全部上游（可被 GC），保留缓存值；_seen 记下当时时钟，期间无写入则读缓存 */
+function orphan(c) {
+    (Orphans || (Orphans = [])).push(c);
+    if (!Flushing)
+        scheduleFlush();
+}
+function detachOrphans() {
+    while (Orphans) {
+        const list = Orphans;
+        Orphans = null;
+        for (let i = 0; i < list.length; i++) {
+            const c = list[i];
+            if (c._subs || c._running || !c._sources)
+                continue;
+            c._seen = c._state === CLEAN ? Clock : -1;
+            cleanNode(c);
+            c._state = DIRTY;
+        }
+    }
+}
+function flush() {
+    if (Flushing) {
+        drain();
+        return;
+    } // FD-36：flush 中再 flushSync 并入当前轮，不复位外层状态
+    Pending = false;
+    Flushing = true;
+    try {
+        drain();
+    }
+    finally {
+        Updates = null;
+        Flushing = false;
+        ++Clock;
+        detachOrphans();
+        if (__DEV__ && flushCbs.size)
+            runFlushCbs();
+    }
+    if (Failed) {
+        const e = FailErr;
+        Failed = false;
+        FailErr = undefined;
+        throw e;
+    }
+}
+/** dev：逐个调用 flush 回调；探针抛错不得影响应用（拷贝一份，允许回调内注销自己） */
+function runFlushCbs() {
+    const list = Array.from(flushCbs);
+    for (let i = 0; i < list.length; i++) {
+        try {
+            list[i]();
+        }
+        catch (e) {
+            console.warn('[warp] __DEV_onFlush 回调抛错（已忽略）：' + String(e));
+        }
+    }
+}
+// ---- R-04 batch ----
+export function batch(fn) {
+    BatchDepth++;
+    try {
+        return runUpdates(fn);
+    }
+    finally {
+        if (--BatchDepth === 0 && Updates)
+            scheduleFlush();
+    }
+}
+/** 同步刷新待处理 effect（测试与 HMR 用） */
+export function flushSync() { if (Updates || Pending)
+    flush(); }
+export function untrack(fn) {
+    const pL = Listener;
+    Listener = null;
+    try {
+        return fn();
+    }
+    finally {
+        Listener = pL;
+    }
+}
+// ---- R-03 依赖清理 ----
+function cleanNode(c) {
+    const src = c._sources;
+    if (src) {
+        if (Array.isArray(src)) {
+            const ss = c._sourceSlots;
+            for (let i = src.length - 1; i >= 0; i--)
+                unsubscribe(src[i], ss[i]);
+        }
+        else
+            unsubscribe(src, c._sourceSlots);
+        c._sources = null;
+        c._sourceSlots = null;
+    }
+    disposeChildren(c);
+    const cl = c._cleanups;
+    if (cl) {
+        c._cleanups = null;
+        for (let i = cl.length - 1; i >= 0; i--)
+            cl[i]();
+    }
+}
+/** owner 子节点：单值直接存，第二个起升级为数组（R-M9） */
+function addChild(o, child) {
+    const ch = o._children;
+    if (!ch)
+        o._children = child;
+    else if (Array.isArray(ch))
+        ch.push(child);
+    else
+        o._children = [ch, child];
+}
+function disposeChildren(o) {
+    const ch = o._children;
+    if (!ch)
+        return;
+    o._children = null;
+    o._dead = 0; // MEM-11：整批释放后压缩计数归零
+    if (Array.isArray(ch)) {
+        for (let i = ch.length - 1; i >= 0; i--)
+            disposeNode(ch[i]);
+    }
+    else
+        disposeNode(ch);
+}
+/** 把 s._subs 中位于 slot 的订阅者移除（swap-remove），并维护被搬动者的反向索引；长度回到 1 时塌回单值 */
+function unsubscribe(s, slot) {
+    const subs = s._subs;
+    if (!subs)
+        return;
+    if (!Array.isArray(subs)) {
+        s._subs = null;
+        s._subSlots = null;
+        if (s._pure)
+            orphan(s);
+        return;
+    }
+    const slots = s._subSlots;
+    const last = subs.pop(), lastSlot = slots.pop();
+    if (slot < subs.length) {
+        subs[slot] = last;
+        slots[slot] = lastSlot;
+        setSourceSlot(last, lastSlot, slot);
+    }
+    if (subs.length === 1) {
+        const only = subs[0], onlySlot = slots[0];
+        s._subs = only;
+        s._subSlots = onlySlot;
+        setSourceSlot(only, onlySlot, 0);
+    }
+}
+function setSourceSlot(c, idxInSources, value) {
+    if (Array.isArray(c._sourceSlots))
+        c._sourceSlots[idxInSources] = value;
+    else
+        c._sourceSlots = value;
+}
+// ---- R-06 owner 树 ----
+function mkComputation(fn, pure, opts) {
+    // R-M4：effect 永远不被订阅，不分配 _v / _eq / _subs / _subSlots（对象少 4 槽）
+    const c = pure ? {
+        _v: undefined, _eq: eqOf(opts), _subs: null, _subSlots: null,
+        _fn: fn, _sources: null, _sourceSlots: null, _state: DIRTY, _pure: true, _running: false, _updatedAt: 0, _seq: ++Seq, _seen: -1,
+        _parent: Owner_, _children: null, _cleanups: null, _context: null, _disposed: false,
+    } : {
+        _fn: fn, _sources: null, _sourceSlots: null, _state: DIRTY, _pure: false, _running: false, _updatedAt: 0, _seq: ++Seq,
+        _parent: Owner_, _children: null, _cleanups: null, _context: null, _disposed: false,
+    };
+    if (__DEV__) {
+        c._name = opts?.name;
+        c._id = ++NextId;
+    }
+    if (Owner_ && !pure)
+        addChild(Owner_, c);
+    if (__DEV__ && pure && Owner_)
+        (Owner_._devC || (Owner_._devC = [])).push(c); // FD-43：computed 不入 owner 树，dev 依赖图仍按创建处枚举
+    return c;
+}
+export function effect(fn, opts) {
+    if (ServerMode) {
+        fn(onCleanup);
+        return NOOP;
+    } // 同步求值一次、不建订阅（清理仍归当前 owner）
+    const c = mkComputation(fn, false, opts);
+    if (__DEV__)
+        devNewOwner(opts?.name);
+    // 创建即跑；仅在 flush / batch 进行中排队以保持顺序（队列仅「待 flush」时仍立即执行）
+    if (Flushing || BatchDepth > 0)
+        Updates.push(c);
+    else
+        runComputation(c);
+    return () => disposeNode(c);
+}
+/** 渲染 effect：创建即同步执行，即使处于 flush / batch 中（runtime-dom `bind` 用；Solid createRenderEffect 语义，DC-23） */
+export function renderEffect(fn, opts) {
+    if (ServerMode) {
+        fn(onCleanup);
+        return NOOP;
+    }
+    const c = mkComputation(fn, false, opts);
+    if (__DEV__)
+        devNewOwner(opts?.name);
+    runComputation(c);
+    return () => disposeNode(c);
+}
+export function computed(fn, opts) {
+    const c = mkComputation(fn, true, opts);
+    return () => readComputed(c);
+}
+export function createRoot(fn, owner = Owner_) {
+    if (__DEV__)
+        devPure();
+    const out = { root: null };
+    return _rootRun(() => fn(() => disposeNode(out.root)), owner, out);
+}
+/** 内部：在新 root 下运行 fn，返回 root 对象本身（不分配 dispose 闭包；runtime-dom 行用，R-M8） */
+export function _rootRun(fn, owner, out) {
+    const parent = owner ?? null;
+    const root = { _parent: parent, _children: null, _cleanups: null, _context: null, _disposed: false };
+    if (__DEV__) {
+        root._id = ++NextId;
+        if (!parent)
+            allRoots.add(root);
+    }
+    if (parent)
+        addChild(parent, root);
+    out.root = root;
+    const pL = Listener, pO = Owner_;
+    Listener = null;
+    Owner_ = root;
+    try {
+        return fn();
+    }
+    finally {
+        Listener = pL;
+        Owner_ = pO;
+    }
+}
+export function _disposeOwner(o) { disposeNode(o); }
+/** 内部（devtools / 测试）：owner 子节点数组视图（单值形态时分配临时数组） */
+export const _childrenOf = __DEV__ ? (o) => { const ch = o._children; return (!ch ? [] : Array.isArray(ch) ? ch : [ch]); } : undefined;
+function disposeNode(n) {
+    if (n._disposed)
+        return;
+    n._disposed = true;
+    // 从父 _children 惰性摘除：计数超过半数时一次压缩（均摊 O(1)，避免长寿命 owner 累积已释放子节点）
+    const p = n._parent;
+    if (p && !p._disposed && p._children) {
+        if (!Array.isArray(p._children)) {
+            if (p._children === n)
+                p._children = null;
+        }
+        else {
+            const dead = (p._dead = (p._dead || 0) + 1);
+            if (dead > 8 && dead * 2 > p._children.length) {
+                p._children = p._children.filter(c => !c._disposed);
+                p._dead = 0;
+            }
+        }
+    }
+    n._context = null; // RDC-26（006 L-35）：两分支共用 —— effect 上 provide 过的 context 也要断开，否则整棵 map 随 owner 泄漏
+    if (isComputation(n)) {
+        cleanNode(n);
+        n._fn = null;
+        if (n._pure)
+            n._v = undefined;
+        n._state = CLEAN;
+    } // MEM-12：effect 无 _v 槽（R-M4），不追加属性触发隐藏类跃迁
+    else {
+        disposeChildren(n);
+        const cl = n._cleanups;
+        if (cl) {
+            n._cleanups = null;
+            for (let i = cl.length - 1; i >= 0; i--)
+                cl[i]();
+        }
+        if (__DEV__ && !n._parent)
+            allRoots.delete(n);
+    }
+}
+/**
+ * @internal 服务端模式开关（ADR-205）。`@warp-ts/server` 进程启动时 `enableServerMode(true)`；
+ * 测试用 `enableServerMode(false)` 还原。
+ */
+export function enableServerMode(on) { ServerMode = on; }
+export function onCleanup(f) {
+    if (Owner_)
+        (Owner_._cleanups || (Owner_._cleanups = [])).push(f);
+    else if (__DEV__)
+        warn('WARP-R101', 'onCleanup');
+}
+export function getOwner() { return Owner_; }
+export function runWithOwner(owner, fn) {
+    const pL = Listener, pO = Owner_;
+    Listener = null;
+    Owner_ = owner;
+    try {
+        return fn();
+    }
+    finally {
+        Listener = pL;
+        Owner_ = pO;
+    }
+}
+/** 内部：owner 上挂错误处理器（core 用） */
+export function _setOwnerError(owner, h) { owner._err = h; }
+/**
+ * 内部：dev 下把组件元信息写到 owner（比照 `_setOwnerError`，REQ-LFE-003 RB-302）。
+ * 与 `__DEV_graph` 同形（prod 为 `undefined`）而不是空函数：prod 里连函数壳都不留（NFR-002 逐字节）。
+ */
+export const _setOwnerDev = __DEV__ ? (owner, info) => {
+    const o = owner;
+    if (info.name !== undefined)
+        o._name = info.name;
+    if (info.hmrId !== undefined)
+        o._hmrId = info.hmrId;
+    if (info.node !== undefined)
+        o._node = info.node;
+} : undefined;
+/** dev：flush 尾部回调登记，返回注销函数；prod 为 `undefined`（与 `__DEV_graph` 同口径） */
+export const __DEV_onFlush = __DEV__ ? (cb) => {
+    flushCbs.add(cb);
+    return () => { flushCbs.delete(cb); };
+} : undefined;
+export function _ownerContext(owner, create) {
+    const o = owner;
+    if (!o._context && create)
+        o._context = new Map();
+    return o._context;
+}
+// Owner 公开只读视图：直接在节点原型上暴露 getter 成本高；这里用 defineProperty 一次性给出的访问函数
+export function ownerView(o) {
+    if (!o)
+        return null;
+    const n = o;
+    return { parent: n._parent, context: n._context, disposed: n._disposed };
+}
+export const __DEV_graph = __DEV__ ? () => {
+    const nodes = [], edges = [], seen = new Set();
+    const visitSig = (s) => {
+        if (s._id === undefined || seen.has(s._id))
+            return;
+        seen.add(s._id);
+        if (isComputation(s))
+            nodes.push({ id: s._id, kind: s._pure ? 'computed' : 'effect', name: s._name, state: s._state, value: s._v });
+        else
+            nodes.push({ id: s._id, kind: 'signal', name: s._name, value: s._v });
+        eachSub(s._subs, c => { visitSig(c); edges.push({ from: s._id, to: c._id, kind: 'dep' }); });
+    };
+    const visitOwner = (o) => {
+        if (o._disposed)
+            return;
+        if (isComputation(o)) {
+            visitSig(o);
+            const srcs = o._sources;
+            if (srcs)
+                for (const s of Array.isArray(srcs) ? srcs : [srcs]) {
+                    if (s._id === undefined)
+                        continue;
+                    visitSig(s);
+                    edges.push({ from: s._id, to: o._id, kind: 'dep' });
+                }
+        } // 匿名节点（selector per-key）不产脏边（B1-06）
+        else if (o._id !== undefined && !seen.has(o._id)) {
+            seen.add(o._id);
+            nodes.push({ id: o._id, kind: 'owner', name: o._name, hmrId: o._hmrId });
+        }
+        const kids = o._children;
+        if (kids)
+            for (const c of Array.isArray(kids) ? kids : [kids]) {
+                if (c._disposed)
+                    continue;
+                visitOwner(c);
+                edges.push({ from: o._id, to: c._id, kind: 'own' });
+            } // 惰性摘除下已释放子节点不产悬空边（MEM-08 / VD-28）
+        const dc = o._devC;
+        if (dc)
+            for (const c of dc) {
+                if (c._disposed)
+                    continue;
+                visitOwner(c);
+                edges.push({ from: o._id, to: c._id, kind: 'own' });
+            }
+    };
+    for (const r of allRoots)
+        visitOwner(r);
+    return { nodes, edges };
+} : undefined;
+// ---- createSelector（NFR-003 select row 优化）----
+/** 返回 `(key) => boolean`：source 变化时只通知旧 key 与新 key 的订阅者，而非全部行（Solid 同名 API） */
+export function createSelector(source, equals = ((a, b) => a === b)) {
+    const subs = new Map();
+    let pruneAt = 64;
+    let value = untrack(source); // RDC-21（006 L-35）：首次求值不得把 source 记进**外层**监听者
+    effect(() => {
+        const v = source();
+        if (Object.is(v, value))
+            return;
+        const prev = value;
+        value = v;
+        let n;
+        subs.forEach((node, key) => { if (!node._subs) {
+            subs.delete(key);
+            return;
+        } if (equals(key, prev) || equals(key, v)) {
+            n = node;
+            if (n)
+                _notify(n);
+        } });
+    });
+    return (key) => {
+        if (Listener) {
+            let n = subs.get(key);
+            if (!n) {
+                // R-M7：不为每个 key 注册清理闭包；map 超过上次剪枝后两倍时扫一遍删除无订阅者的 key（均摊 O(1)）
+                // 上界（MEM-07 接受）：源不变且无新 key 时死条目最多保留至 max(64, 2 × 峰值)，每条 ≈ 40 B；key 请用原始值（对象 key 会连带持有对象图，见 guide 02）
+                if (subs.size >= pruneAt) {
+                    subs.forEach((node, k) => { if (!node._subs)
+                        subs.delete(k); });
+                    pruneAt = Math.max(64, subs.size * 2);
+                }
+                n = _mkSignalNode();
+                subs.set(key, n);
+            }
+            readSignal(n);
+        }
+        return equals(key, value);
+    };
+}