@warp-ts/reactivity 0.0.0-stage → 0.1.3

package/dist/index.dev.js

@@ -0,0 +1,973 @@
+//#region src/types.ts
+function isComputation(n) {
+	return n._pure !== void 0;
+}
+
+//#endregion
+//#region src/error.ts
+var WarpError = class extends Error {
+	constructor(code, message, hint) {
+		super(`[${code}] ${message}`);
+		this.name = "WarpError";
+		this.code = code;
+		this.hint = hint;
+	}
+};
+const MSG = {
+	"WARP-R101": (n) => `effect "${n}" 创建于无 owner 上下文，将永不释放；请放入组件 / createRoot 内`,
+	"WARP-R102": (n) => `检测到依赖环：${n}`,
+	"WARP-R103": (n) => `不能写入 computed "${n}"`,
+	"WARP-R104": (n) => `computed "${n}" 内写入了 signal，computed 必须是纯函数`,
+	"WARP-R105": (n) => `computed "${n}" 内创建了 effect / createRoot，computed 必须是纯函数（重算不会释放它们）`
+};
+function err(code, name) {
+	{
+		const f = MSG[code];
+		if (f) return new WarpError(code, f(name || "(anonymous)"));
+	}
+	return new WarpError(code, code);
+}
+function warn(code, name) {
+	console.warn(err(code, name).message);
+}
+
+//#endregion
+//#region src/core.ts
+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;
+let FailErr;
+/** dev：顶层 root 登记，供依赖图快照 */
+const allRoots = /* @__PURE__ */ new Set();
+/** dev：flush 尾部回调（DevTools 探针的唯一插桩点，REQ-LFE-003 RB-301） */
+const flushCbs = /* @__PURE__ */ new Set();
+/**
+* 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 === void 0) return Object.is;
+	if (o.equals === false) return () => false;
+	return o.equals;
+}
+function signal(v, opts) {
+	const n = {
+		_v: v,
+		_eq: eqOf(opts),
+		_subs: null,
+		_subSlots: null
+	};
+	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) {
+		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 === void 0) {
+			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) {
+	if (isComputation(n)) throw err("WARP-R103", n._name);
+	if (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, 2)));
+}
+/** 遍历订阅者（单值或数组）；遍历期间不修改集合 */
+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）触发 */
+function _notify(n) {
+	++Clock;
+	if (n._subs) runUpdates(() => eachSub(n._subs, (c) => markDirty(c, 2)));
+}
+const _track = readSignal;
+function _mkSignalNode() {
+	return {
+		_v: void 0,
+		_eq: () => false,
+		_subs: null,
+		_subSlots: null
+	};
+}
+function _hasListener() {
+	return Listener !== null;
+}
+/** 内部：轻量信号（runtime-dom 行 item / index 用）：只有节点 + 一个读闭包，写入走 _write，省去 set / peek 闭包（内存专项 M-1） */
+function _lightSignal(v) {
+	const node = {
+		_v: v,
+		_eq: Object.is,
+		_subs: null,
+		_subSlots: null
+	};
+	node._id = ++NextId;
+	return {
+		read: () => readSignal(node),
+		node
+	};
+}
+const _write = writeSignal;
+function markDirty(c, state) {
+	if (c._state >= state) return;
+	const was = c._state;
+	c._state = state;
+	if (was === 0 && !c._pure) Updates.push(c);
+	eachSub(c._subs, (s) => markDirty(s, 1));
+}
+function readComputed(c) {
+	if (c._running) throw err("WARP-R102", `computed "${c._name || "(anonymous)"}" 在自身求值期间被读取`);
+	if (c._state !== 0 && !(c._seen === Clock && !Listener)) updateIfNecessary(c);
+	if (!Listener && !c._subs && c._sources) orphan(c);
+	return readSignal(c);
+}
+function updateIfNecessary(c) {
+	if (c._disposed) return;
+	if (c._state === 1) {
+		const src = c._sources;
+		const check = (s) => {
+			if (isComputation(s)) {
+				updateIfNecessary(s);
+				if (s._updatedAt > c._updatedAt) {
+					c._state = 2;
+					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 === 1) c._state = 0;
+	}
+	if (c._state === 2) runComputation(c);
+}
+function runComputation(c) {
+	cleanNode(c);
+	c._state = 0;
+	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);
+		if (c._pure && (!c._updatedAt || !c._eq(c._v, nv))) {
+			c._v = nv;
+			c._updatedAt = ++Clock;
+			eachSub(c._subs, (s) => markDirty(s, 2));
+		} 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 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 (++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 !== 0) 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 === 0 ? Clock : -1;
+			cleanNode(c);
+			c._state = 2;
+		}
+	}
+}
+function flush() {
+	if (Flushing) {
+		drain();
+		return;
+	}
+	Pending = false;
+	Flushing = true;
+	try {
+		drain();
+	} finally {
+		Updates = null;
+		Flushing = false;
+		++Clock;
+		detachOrphans();
+		if (flushCbs.size) runFlushCbs();
+	}
+	if (Failed) {
+		const e = FailErr;
+		Failed = false;
+		FailErr = void 0;
+		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));
+	}
+}
+function batch(fn) {
+	BatchDepth++;
+	try {
+		return runUpdates(fn);
+	} finally {
+		if (--BatchDepth === 0 && Updates) scheduleFlush();
+	}
+}
+/** 同步刷新待处理 effect（测试与 HMR 用） */
+function flushSync() {
+	if (Updates || Pending) flush();
+}
+function untrack(fn) {
+	const pL = Listener;
+	Listener = null;
+	try {
+		return fn();
+	} finally {
+		Listener = pL;
+	}
+}
+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;
+	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;
+}
+function mkComputation(fn, pure, opts) {
+	const c = pure ? {
+		_v: void 0,
+		_eq: eqOf(opts),
+		_subs: null,
+		_subSlots: null,
+		_fn: fn,
+		_sources: null,
+		_sourceSlots: null,
+		_state: 2,
+		_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: 2,
+		_pure: false,
+		_running: false,
+		_updatedAt: 0,
+		_seq: ++Seq,
+		_parent: Owner_,
+		_children: null,
+		_cleanups: null,
+		_context: null,
+		_disposed: false
+	};
+	c._name = opts?.name;
+	c._id = ++NextId;
+	if (Owner_ && !pure) addChild(Owner_, c);
+	if (pure && Owner_) (Owner_._devC || (Owner_._devC = [])).push(c);
+	return c;
+}
+function effect(fn, opts) {
+	if (ServerMode) {
+		fn(onCleanup);
+		return NOOP;
+	}
+	const c = mkComputation(fn, false, opts);
+	devNewOwner(opts?.name);
+	if (Flushing || BatchDepth > 0) Updates.push(c);
+	else runComputation(c);
+	return () => disposeNode(c);
+}
+/** 渲染 effect：创建即同步执行，即使处于 flush / batch 中（runtime-dom `bind` 用；Solid createRenderEffect 语义，DC-23） */
+function renderEffect(fn, opts) {
+	if (ServerMode) {
+		fn(onCleanup);
+		return NOOP;
+	}
+	const c = mkComputation(fn, false, opts);
+	devNewOwner(opts?.name);
+	runComputation(c);
+	return () => disposeNode(c);
+}
+function computed(fn, opts) {
+	const c = mkComputation(fn, true, opts);
+	return () => readComputed(c);
+}
+function createRoot(fn, owner = Owner_) {
+	devPure();
+	const out = { root: null };
+	return _rootRun(() => fn(() => disposeNode(out.root)), owner, out);
+}
+/** 内部：在新 root 下运行 fn，返回 root 对象本身（不分配 dispose 闭包；runtime-dom 行用，R-M8） */
+function _rootRun(fn, owner, out) {
+	const parent = owner ?? null;
+	const root = {
+		_parent: parent,
+		_children: null,
+		_cleanups: null,
+		_context: null,
+		_disposed: false
+	};
+	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;
+	}
+}
+function _disposeOwner(o) {
+	disposeNode(o);
+}
+/** 内部（devtools / 测试）：owner 子节点数组视图（单值形态时分配临时数组） */
+const _childrenOf = (o) => {
+	const ch = o._children;
+	return !ch ? [] : Array.isArray(ch) ? ch : [ch];
+};
+function disposeNode(n) {
+	if (n._disposed) return;
+	n._disposed = true;
+	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;
+	if (isComputation(n)) {
+		cleanNode(n);
+		n._fn = null;
+		if (n._pure) n._v = void 0;
+		n._state = 0;
+	} else {
+		disposeChildren(n);
+		const cl = n._cleanups;
+		if (cl) {
+			n._cleanups = null;
+			for (let i = cl.length - 1; i >= 0; i--) cl[i]();
+		}
+		if (!n._parent) allRoots.delete(n);
+	}
+}
+/**
+* @internal 服务端模式开关（ADR-205）。`@warp-ts/server` 进程启动时 `enableServerMode(true)`；
+* 测试用 `enableServerMode(false)` 还原。
+*/
+function enableServerMode(on) {
+	ServerMode = on;
+}
+function onCleanup(f) {
+	if (Owner_) (Owner_._cleanups || (Owner_._cleanups = [])).push(f);
+	else warn("WARP-R101", "onCleanup");
+}
+function getOwner() {
+	return Owner_;
+}
+function runWithOwner(owner, fn) {
+	const pL = Listener, pO = Owner_;
+	Listener = null;
+	Owner_ = owner;
+	try {
+		return fn();
+	} finally {
+		Listener = pL;
+		Owner_ = pO;
+	}
+}
+/** 内部：owner 上挂错误处理器（core 用） */
+function _setOwnerError(owner, h) {
+	owner._err = h;
+}
+/**
+* 内部：dev 下把组件元信息写到 owner（比照 `_setOwnerError`，REQ-LFE-003 RB-302）。
+* 与 `__DEV_graph` 同形（prod 为 `undefined`）而不是空函数：prod 里连函数壳都不留（NFR-002 逐字节）。
+*/
+const _setOwnerDev = (owner, info) => {
+	const o = owner;
+	if (info.name !== void 0) o._name = info.name;
+	if (info.hmrId !== void 0) o._hmrId = info.hmrId;
+	if (info.node !== void 0) o._node = info.node;
+};
+/** dev：flush 尾部回调登记，返回注销函数；prod 为 `undefined`（与 `__DEV_graph` 同口径） */
+const __DEV_onFlush = (cb) => {
+	flushCbs.add(cb);
+	return () => {
+		flushCbs.delete(cb);
+	};
+};
+function _ownerContext(owner, create) {
+	const o = owner;
+	if (!o._context && create) o._context = /* @__PURE__ */ new Map();
+	return o._context;
+}
+function ownerView(o) {
+	if (!o) return null;
+	const n = o;
+	return {
+		parent: n._parent,
+		context: n._context,
+		disposed: n._disposed
+	};
+}
+const __DEV_graph = () => {
+	const nodes = [], edges = [], seen = /* @__PURE__ */ new Set();
+	const visitSig = (s) => {
+		if (s._id === void 0 || 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 === void 0) continue;
+				visitSig(s);
+				edges.push({
+					from: s._id,
+					to: o._id,
+					kind: "dep"
+				});
+			}
+		} else if (o._id !== void 0 && !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"
+			});
+		}
+		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
+	};
+};
+/** 返回 `(key) => boolean`：source 变化时只通知旧 key 与新 key 的订阅者，而非全部行（Solid 同名 API） */
+function createSelector(source, equals = ((a, b) => a === b)) {
+	const subs = /* @__PURE__ */ new Map();
+	let pruneAt = 64;
+	let value = untrack(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) {
+				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);
+	};
+}
+
+//#endregion
+//#region src/reactive.ts
+const RAW = Symbol("warp.raw");
+const ITERATE = Symbol("warp.iterate");
+const proxyMap = /* @__PURE__ */ new WeakMap();
+const shallowMap = /* @__PURE__ */ new WeakMap();
+const depMap = /* @__PURE__ */ new WeakMap();
+function track(raw, key) {
+	if (!_hasListener()) return;
+	let m = depMap.get(raw);
+	if (!m) depMap.set(raw, m = /* @__PURE__ */ new Map());
+	let n = m.get(key);
+	if (!n) m.set(key, n = _mkSignalNode());
+	_track(n);
+}
+function trigger(raw, key, alsoIterate = false, keys) {
+	const m = depMap.get(raw);
+	if (!m) return;
+	batch(() => {
+		const fire = (n) => {
+			if (n) _notify(n);
+		};
+		fire(m.get(key));
+		if (keys) for (const k of keys) fire(m.get(k));
+		if (alsoIterate) {
+			fire(m.get(ITERATE));
+			if (Array.isArray(raw)) fire(m.get("length"));
+		}
+	});
+}
+function toRaw(o) {
+	return o && o[RAW] || o;
+}
+function isReactive(o) {
+	return !!(o && o[RAW]);
+}
+function canProxy(o) {
+	if (!o || typeof o !== "object" || Object.isFrozen(o) || !Object.isExtensible(o)) return false;
+	const t = Object.prototype.toString.call(o);
+	return /^\[object (Object|Array|Map|Set|WeakMap|WeakSet)\]$/.test(t);
+}
+function wrap(v, shallow) {
+	return shallow || !canProxy(v) ? v : createProxy(v, false);
+}
+const arrayInst = {};
+for (const m of [
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse"
+]) arrayInst[m] = function(...args) {
+	const raw = toRaw(this);
+	const before = raw.length;
+	args = args.map(toRaw);
+	const r = batch(() => untrack(() => Array.prototype[m].apply(raw, args)));
+	if (m === "sort" || m === "reverse") trigger(raw, ITERATE, true, Array.from(raw.keys(), String));
+	else {
+		const after = raw.length;
+		const lo = m === "push" ? before : m === "pop" ? after : 0;
+		const hi = Math.max(before, after);
+		const ks = [];
+		for (let i = lo; i < hi; i++) ks.push(String(i));
+		trigger(raw, "length", true, ks);
+	}
+	return r;
+};
+for (const m of [
+	"includes",
+	"indexOf",
+	"lastIndexOf"
+]) arrayInst[m] = function(...args) {
+	const raw = toRaw(this);
+	track(raw, "length");
+	for (let i = 0; i < raw.length; i++) track(raw, String(i));
+	const fn = Array.prototype[m];
+	const r = fn.apply(raw, args);
+	if ((r === -1 || r === false) && args.length) return fn.apply(raw, [toRaw(args[0]), ...args.slice(1)]);
+	return r;
+};
+function baseHandlers(shallow) {
+	return {
+		get(raw, key, receiver) {
+			if (key === RAW) return raw;
+			if (Array.isArray(raw) && typeof key === "string" && Object.prototype.hasOwnProperty.call(arrayInst, key)) return arrayInst[key];
+			track(raw, key);
+			return wrap(Reflect.get(raw, key, receiver), shallow);
+		},
+		set(raw, key, v, receiver) {
+			v = toRaw(v);
+			const had = Object.prototype.hasOwnProperty.call(raw, key);
+			const old = raw[key];
+			const isArr = Array.isArray(raw);
+			const oldLen = isArr ? raw.length : 0;
+			const ok = Reflect.set(raw, key, v, receiver);
+			if (!had) trigger(raw, key, true);
+			else if (!Object.is(old, v)) {
+				if (isArr && key === "length") {
+					const ks = [];
+					for (let i = v; i < oldLen; i++) ks.push(String(i));
+					trigger(raw, "length", true, ks);
+				} else trigger(raw, key);
+			}
+			if (isArr && key !== "length" && raw.length !== oldLen) trigger(raw, "length", true);
+			return ok;
+		},
+		deleteProperty(raw, key) {
+			const had = Object.prototype.hasOwnProperty.call(raw, key);
+			const ok = Reflect.deleteProperty(raw, key);
+			if (had && ok) trigger(raw, key, true);
+			return ok;
+		},
+		has(raw, key) {
+			if (key !== RAW) track(raw, key);
+			return Reflect.has(raw, key);
+		},
+		ownKeys(raw) {
+			track(raw, ITERATE);
+			if (Array.isArray(raw)) track(raw, "length");
+			return Reflect.ownKeys(raw);
+		}
+	};
+}
+function collHandlers(shallow, weak) {
+	const inst = {
+		get(k) {
+			const raw = toRaw(this);
+			k = toRaw(k);
+			track(raw, k);
+			return wrap(raw.get(k), shallow);
+		},
+		has(k) {
+			const raw = toRaw(this);
+			k = toRaw(k);
+			track(raw, k);
+			return raw.has(k);
+		},
+		set(k, v) {
+			const raw = toRaw(this);
+			k = toRaw(k);
+			v = toRaw(v);
+			const had = raw.has(k);
+			const old = raw.get(k);
+			raw.set(k, v);
+			if (!had) trigger(raw, k, true);
+			else if (!Object.is(old, v)) trigger(raw, k);
+			return this;
+		},
+		add(v) {
+			const raw = toRaw(this);
+			v = toRaw(v);
+			if (!raw.has(v)) {
+				raw.add(v);
+				trigger(raw, v, true);
+			}
+			return this;
+		},
+		delete(k) {
+			const raw = toRaw(this);
+			k = toRaw(k);
+			const had = raw.has(k);
+			const r = raw.delete(k);
+			if (had) trigger(raw, k, true);
+			return r;
+		},
+		clear() {
+			const raw = toRaw(this);
+			const ks = [...raw.keys()];
+			const had = ks.length > 0;
+			raw.clear();
+			if (had) trigger(raw, ITERATE, true, ks);
+		},
+		forEach(cb, thisArg) {
+			const raw = toRaw(this);
+			track(raw, ITERATE);
+			raw.forEach((v, k) => cb.call(thisArg, wrap(v, shallow), wrap(k, shallow), this));
+		}
+	};
+	const iter = (name) => function() {
+		const raw = toRaw(this);
+		track(raw, ITERATE);
+		const isEntries = name === "entries" || name === Symbol.iterator && raw instanceof Map;
+		const it = raw[name].call(raw);
+		return {
+			next() {
+				const r = it.next();
+				if (r.done) return r;
+				const v = r.value;
+				return {
+					done: false,
+					value: isEntries ? [wrap(v[0], shallow), wrap(v[1], shallow)] : wrap(v, shallow)
+				};
+			},
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
+	};
+	if (weak) {
+		delete inst.clear;
+		delete inst.forEach;
+	} else {
+		inst.keys = iter("keys");
+		inst.values = iter("values");
+		inst.entries = iter("entries");
+		inst[Symbol.iterator] = iter(Symbol.iterator);
+	}
+	return { get(raw, key, receiver) {
+		if (key === RAW) return raw;
+		if (key === "size" && !weak) {
+			track(raw, ITERATE);
+			return Reflect.get(raw, "size", raw);
+		}
+		if (Object.prototype.hasOwnProperty.call(inst, key)) return inst[key];
+		return Reflect.get(raw, key, receiver);
+	} };
+}
+function createProxy(o, shallow) {
+	const raw = toRaw(o);
+	const cache = shallow ? shallowMap : proxyMap;
+	const hit = cache.get(raw);
+	if (hit) return hit;
+	const weak = raw instanceof WeakMap || raw instanceof WeakSet;
+	const isColl = weak || raw instanceof Map || raw instanceof Set;
+	const p = new Proxy(raw, isColl ? collHandlers(shallow, weak) : baseHandlers(shallow));
+	cache.set(raw, p);
+	return p;
+}
+function reactive(o) {
+	return canProxy(o) ? createProxy(o, false) : o;
+}
+function shallowReactive(o) {
+	return canProxy(o) ? createProxy(o, true) : o;
+}
+
+//#endregion
+export { WarpError, __DEV_graph, __DEV_onFlush, _childrenOf, _disposeOwner, _hasListener, _lightSignal, _mkSignalNode, _notify, _ownerContext, _rootRun, _setOwnerDev, _setOwnerError, _track, _write, batch, computed, createRoot, createSelector, effect, enableServerMode, flushSync, getOwner, isReactive, onCleanup, ownerView, reactive, renderEffect, runWithOwner, shallowReactive, signal, toRaw, untrack };