@hedystia/view 2.1.0

package/dist/scheduler/scheduler.mjs

@@ -0,0 +1,59 @@
+//#region src/scheduler/scheduler.ts
+/**
+* Frame scheduler for @hedystia/view
+*
+* Provides requestAnimationFrame-based batching for visual updates.
+*/
+let scheduledRaf = null;
+let rafCallbacks = [];
+/**
+* Schedule a callback for the next animation frame
+* @param {() => void} fn - The callback to run on next frame
+* @example
+* tick(() => {
+*   // DOM updates here
+* });
+*/
+function tick(fn) {
+	rafCallbacks.push(fn);
+	if (scheduledRaf === null) scheduledRaf = requestAnimationFrame(flushRaf);
+}
+/**
+* Wait for the next animation frame
+* @returns {Promise<void>} A promise that resolves on next frame
+* @example
+* await nextFrame();
+*/
+function nextFrame() {
+	return new Promise((resolve) => {
+		tick(resolve);
+	});
+}
+/** @internal */
+function flushRaf() {
+	scheduledRaf = null;
+	const callbacks = rafCallbacks;
+	rafCallbacks = [];
+	for (let i = 0; i < callbacks.length; i++) callbacks[i]();
+}
+/**
+* Force flush all pending RAF callbacks synchronously (for testing)
+* @example
+* await tick(); // forces flush
+*/
+function forceFlush() {
+	return new Promise((resolve) => {
+		if (scheduledRaf !== null) {
+			cancelAnimationFrame(scheduledRaf);
+			scheduledRaf = null;
+		}
+		const callbacks = rafCallbacks;
+		rafCallbacks = [];
+		for (let i = 0; i < callbacks.length; i++) callbacks[i]();
+		resolve();
+	});
+}
+//#endregion
+export { forceFlush, nextFrame, tick };
+
+//# sourceMappingURL=scheduler.mjs.map

package/dist/scheduler/scheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.mjs","names":[],"sources":["../../src/scheduler/scheduler.ts"],"sourcesContent":["/**\n * Frame scheduler for @hedystia/view\n *\n * Provides requestAnimationFrame-based batching for visual updates.\n */\n\nlet scheduledRaf: number | null = null;\nlet rafCallbacks: Array<() => void> = [];\n\n/**\n * Schedule a callback for the next animation frame\n * @param {() => void} fn - The callback to run on next frame\n * @example\n * tick(() => {\n *   // DOM updates here\n * });\n */\nexport function tick(fn: () => void): void {\n  rafCallbacks.push(fn);\n  if (scheduledRaf === null) {\n    scheduledRaf = requestAnimationFrame(flushRaf);\n  }\n}\n\n/**\n * Wait for the next animation frame\n * @returns {Promise<void>} A promise that resolves on next frame\n * @example\n * await nextFrame();\n */\nexport function nextFrame(): Promise<void> {\n  return new Promise((resolve) => {\n    tick(resolve);\n  });\n}\n\n/** @internal */\nfunction flushRaf(): void {\n  scheduledRaf = null;\n  const callbacks = rafCallbacks;\n  rafCallbacks = [];\n  for (let i = 0; i < callbacks.length; i++) {\n    callbacks[i]!();\n  }\n}\n\n/**\n * Force flush all pending RAF callbacks synchronously (for testing)\n * @example\n * await tick(); // forces flush\n */\nexport function forceFlush(): Promise<void> {\n  return new Promise((resolve) => {\n    if (scheduledRaf !== null) {\n      cancelAnimationFrame(scheduledRaf);\n      scheduledRaf = null;\n    }\n    const callbacks = rafCallbacks;\n    rafCallbacks = [];\n    for (let i = 0; i < callbacks.length; i++) {\n      callbacks[i]!();\n    }\n    resolve();\n  });\n}\n"],"mappings":";;;;;;AAMA,IAAI,eAA8B;AAClC,IAAI,eAAkC,EAAE;;;;;;;;;AAUxC,SAAgB,KAAK,IAAsB;AACzC,cAAa,KAAK,GAAG;AACrB,KAAI,iBAAiB,KACnB,gBAAe,sBAAsB,SAAS;;;;;;;;AAUlD,SAAgB,YAA2B;AACzC,QAAO,IAAI,SAAS,YAAY;AAC9B,OAAK,QAAQ;GACb;;;AAIJ,SAAS,WAAiB;AACxB,gBAAe;CACf,MAAM,YAAY;AAClB,gBAAe,EAAE;AACjB,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,IACpC,WAAU,IAAK;;;;;;;AASnB,SAAgB,aAA4B;AAC1C,QAAO,IAAI,SAAS,YAAY;AAC9B,MAAI,iBAAiB,MAAM;AACzB,wBAAqB,aAAa;AAClC,kBAAe;;EAEjB,MAAM,YAAY;AAClB,iBAAe,EAAE;AACjB,OAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,IACpC,WAAU,IAAK;AAEjB,WAAS;GACT"}

package/dist/signal/signal.cjs

@@ -0,0 +1,387 @@
+const require_index = require("../utils/index.cjs");
+//#region src/signal/signal.ts
+/** @internal */
+let Owner = null;
+/** @internal */
+let Listener = null;
+/** @internal */
+let Updates = null;
+/** @internal */
+let Pending = null;
+/**
+* Create a reactive signal with an initial value
+*/
+function sig(initial, options) {
+	return {
+		_value: initial,
+		_observers: null,
+		_observerSlots: null,
+		_comparator: options?.equals !== void 0 ? options.equals : require_index.equalFn
+	};
+}
+/**
+* Read the value of a signal, registering a dependency if inside a reactive context
+*/
+function val(signal) {
+	if (Listener !== null) {
+		if (signal._observers === null) {
+			signal._observers = [];
+			signal._observerSlots = [];
+		}
+		let index = signal._observers.indexOf(Listener);
+		if (index === -1) {
+			index = signal._observers.length;
+			signal._observers.push(Listener);
+			signal._observerSlots.push(Listener._sources === null ? 0 : Listener._sources.length);
+			if (Listener._sources === null) {
+				Listener._sources = [];
+				Listener._sourceSlots = [];
+			}
+			Listener._sources.push(signal);
+			Listener._sourceSlots.push(index);
+		}
+	}
+	const computed = signal;
+	if (computed._state === 1) recompute(computed);
+	return signal._value;
+}
+/** @internal - Remove a computation from all its source observer lists */
+function cleanupSources(computation) {
+	if (computation._sources !== null) {
+		for (let j = computation._sources.length - 1; j >= 0; j--) {
+			const source = computation._sources[j];
+			const index = computation._sourceSlots[j];
+			const obs = source._observers;
+			const obsSlots = source._observerSlots;
+			if (obs && obsSlots && index < obs.length) {
+				const last = obs.pop();
+				const lastSlot = obsSlots.pop();
+				if (index < obs.length) {
+					obs[index] = last;
+					obsSlots[index] = lastSlot;
+					if (last._sourceSlots) last._sourceSlots[lastSlot] = index;
+				}
+			}
+		}
+		computation._sources = null;
+		computation._sourceSlots = null;
+	}
+}
+/** @internal - Run a computation with proper Listener tracking */
+function runComputation(computation) {
+	const prevListener = Listener;
+	const prevOwner = Owner;
+	cleanupSources(computation);
+	Listener = computation;
+	Owner = computation._owner;
+	try {
+		const value = computation._fn(computation._value);
+		computation._value = value;
+		computation._state = 0;
+		const computed = computation._computed;
+		if (computed) {
+			computed._value = value;
+			computed._state = 0;
+		}
+		return value;
+	} finally {
+		Listener = prevListener;
+		Owner = prevOwner;
+	}
+}
+/** @internal */
+function recompute(computed) {
+	const computation = computed._computation;
+	if (!computation?._fn) return;
+	runComputation(computation);
+}
+/**
+* Set the value of a signal, notifying dependents
+*/
+function set(signal, value) {
+	const comparator = signal._comparator;
+	if (comparator?.(signal._value, value)) return value;
+	signal._value = value;
+	if (signal._observers !== null) scheduleUpdate(signal);
+	return value;
+}
+/**
+* Update a signal's value using a function of the previous value
+*/
+function update(signal, fn) {
+	return set(signal, fn(signal._value));
+}
+/**
+* Read a signal's value without registering a dependency
+*/
+function peek(signal) {
+	return signal._value;
+}
+/** @internal - Propagate stale state through computed/memo observers */
+function markDownstream(node) {
+	const observers = node._observers;
+	if (!observers) return;
+	for (let i = 0; i < observers.length; i++) {
+		const observer = observers[i];
+		if (observer._state !== 0) continue;
+		observer._state = 1;
+		const computed = observer._computed;
+		if (computed) {
+			computed._state = 1;
+			markDownstream(computed);
+		}
+		if (observer._user) {
+			if (Pending === null) Pending = [];
+			Pending.push(observer);
+		}
+	}
+}
+/** @internal */
+function scheduleUpdate(signal) {
+	const observers = signal._observers;
+	if (observers === null) return;
+	for (let i = 0; i < observers.length; i++) {
+		const observer = observers[i];
+		if (observer._state === 0) {
+			observer._state = 1;
+			const computed = observer._computed;
+			if (computed) {
+				computed._state = 1;
+				markDownstream(computed);
+			}
+			if (Pending === null) Pending = [];
+			Pending.push(observer);
+		}
+	}
+	if (Updates === null) flushUpdates();
+}
+/** @internal */
+function flushUpdates() {
+	const updates = Pending;
+	Pending = null;
+	if (updates === null) return;
+	for (let i = 0; i < updates.length; i++) {
+		const computation = updates[i];
+		if (computation._user && computation._state === 1) runComputation(computation);
+	}
+	Updates = null;
+}
+/**
+* Create a derived reactive signal (computed value)
+*/
+function memo(fn) {
+	const computed = {
+		_fn: fn,
+		_value: void 0,
+		_observers: null,
+		_observerSlots: null,
+		_sources: null,
+		_sourceSlots: null,
+		_state: 1
+	};
+	const computation = {
+		_fn: fn,
+		_value: void 0,
+		_sources: null,
+		_sourceSlots: null,
+		_observers: null,
+		_observerSlots: null,
+		_owner: Owner,
+		_cleanups: null,
+		_context: null,
+		_suspense: null,
+		_user: false,
+		_pure: true,
+		_state: 1,
+		_updatedAt: null
+	};
+	computed._computation = computation;
+	computation._computed = computed;
+	const callable = (() => {
+		if (computed._state === 1) recompute(computed);
+		return computed._value;
+	});
+	Object.defineProperty(callable, "_state", {
+		get() {
+			return computed._state;
+		},
+		set(v) {
+			computed._state = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_value", {
+		get() {
+			return computed._value;
+		},
+		set(v) {
+			computed._value = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_observers", {
+		get() {
+			return computed._observers;
+		},
+		set(v) {
+			computed._observers = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_observerSlots", {
+		get() {
+			return computed._observerSlots;
+		},
+		set(v) {
+			computed._observerSlots = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_sources", {
+		get() {
+			return computed._sources;
+		},
+		set(v) {
+			computed._sources = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_sourceSlots", {
+		get() {
+			return computed._sourceSlots;
+		},
+		set(v) {
+			computed._sourceSlots = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_fn", {
+		get() {
+			return computed._fn;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(callable, "_computation", {
+		get() {
+			return computed._computation;
+		},
+		set(v) {
+			computed._computation = v;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	recompute(computed);
+	return callable;
+}
+/**
+* Execute a function without tracking signal dependencies
+*/
+function untrack(fn) {
+	const prevListener = Listener;
+	Listener = null;
+	try {
+		return fn();
+	} finally {
+		Listener = prevListener;
+	}
+}
+/**
+* Batch multiple signal updates into a single reactive cycle
+*/
+function batch(fn) {
+	const prevUpdates = Updates;
+	const prevPending = Pending;
+	Updates = [];
+	Pending = [];
+	try {
+		fn();
+	} finally {
+		if (prevPending !== null && prevPending.length > 0) Pending = prevPending.concat(Pending);
+		Updates = prevUpdates;
+		flushUpdates();
+	}
+}
+/**
+* Create a reactive root context
+*/
+function createRoot(fn) {
+	const prevOwner = Owner;
+	const prevListener = Listener;
+	const root = {
+		_owned: null,
+		_cleanups: null,
+		_owner: prevOwner,
+		_context: null
+	};
+	Owner = root;
+	Listener = null;
+	try {
+		return fn(() => cleanRoot(root));
+	} finally {
+		Owner = prevOwner;
+		Listener = prevListener;
+	}
+}
+/** @internal */
+function cleanRoot(root) {
+	if (root._cleanups !== null) {
+		const cleanups = root._cleanups;
+		root._cleanups = null;
+		for (let i = cleanups.length - 1; i >= 0; i--) cleanups[i]();
+	}
+	if (root._owned !== null) {
+		const owned = root._owned;
+		root._owned = null;
+		for (let i = 0; i < owned.length; i++) cleanNode(owned[i]);
+	}
+}
+/**
+* Register a cleanup callback to run when the owner is disposed
+*/
+function onCleanup(fn) {
+	if (Owner === null) return;
+	if (Owner._cleanups === null) Owner._cleanups = [];
+	Owner._cleanups.push(fn);
+}
+/** @internal */
+function cleanNode(node) {
+	if ("_cleanups" in node && node._cleanups !== null) {
+		const cleanups = node._cleanups;
+		node._cleanups = null;
+		for (let i = cleanups.length - 1; i >= 0; i--) cleanups[i]();
+	}
+	if ("_owned" in node && node._owned !== null) {
+		const owned = node._owned;
+		node._owned = null;
+		for (let i = 0; i < owned.length; i++) cleanNode(owned[i]);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "Owner", {
+	enumerable: true,
+	get: function() {
+		return Owner;
+	}
+});
+exports.batch = batch;
+exports.cleanupSources = cleanupSources;
+exports.createRoot = createRoot;
+exports.memo = memo;
+exports.onCleanup = onCleanup;
+exports.peek = peek;
+exports.runComputation = runComputation;
+exports.set = set;
+exports.sig = sig;
+exports.untrack = untrack;
+exports.update = update;
+exports.val = val;
+
+//# sourceMappingURL=signal.cjs.map

package/dist/signal/signal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.cjs","names":["equalFn"],"sources":["../../src/signal/signal.ts"],"sourcesContent":["/**\n * Reactive signal system for @hedystia/view\n *\n * Signals provide mutable state with automatic dependency tracking.\n */\n\nimport type {\n  Computation,\n  Computed,\n  EffectFunction,\n  Owner as OwnerType,\n  Signal,\n  SignalOptions,\n} from \"../types\";\nimport { equalFn } from \"../utils\";\n\n/** @internal */\nexport let Owner: OwnerType | null = null;\n\n/** @internal */\nexport let Listener: Computation<any> | null = null;\n\n/** @internal */\nlet Updates: Computation<any>[] | null = null;\n\n/** @internal */\nconst _Effects: Computation<any>[] | null = null;\n\n/** @internal */\nexport let Pending: Computation<any>[] | null = null;\n\n/**\n * Create a reactive signal with an initial value\n */\nexport function sig<T>(initial: T, options?: SignalOptions<T>): Signal<T> {\n  const s: Signal<T> = {\n    _value: initial,\n    _observers: null,\n    _observerSlots: null,\n    _comparator: options?.equals !== undefined ? (options.equals as any) : equalFn,\n  };\n  return s;\n}\n\n/**\n * Read the value of a signal, registering a dependency if inside a reactive context\n */\nexport function val<T>(signal: Signal<T> | Computed<T>): T {\n  if (Listener !== null) {\n    if (signal._observers === null) {\n      signal._observers = [];\n      signal._observerSlots = [];\n    }\n\n    // Check if already registered\n    let index = signal._observers.indexOf(Listener);\n    if (index === -1) {\n      index = signal._observers.length;\n      signal._observers.push(Listener);\n      signal._observerSlots!.push(Listener._sources === null ? 0 : Listener._sources.length);\n\n      if (Listener._sources === null) {\n        Listener._sources = [];\n        Listener._sourceSlots = [];\n      }\n      Listener._sources.push(signal);\n      Listener._sourceSlots!.push(index);\n    }\n  }\n\n  // Check if computed needs re-evaluation\n  const computed = signal as Computed<T>;\n  if (computed._state === 1) {\n    recompute(computed);\n  }\n\n  return signal._value;\n}\n\n/** @internal - Remove a computation from all its source observer lists */\nexport function cleanupSources(computation: Computation<any>): void {\n  if (computation._sources !== null) {\n    for (let j = computation._sources.length - 1; j >= 0; j--) {\n      const source: Signal<any> = computation._sources[j]!;\n      const index = computation._sourceSlots![j]!;\n      const obs = source._observers;\n      const obsSlots: number[] | null = source._observerSlots;\n      if (obs && obsSlots && index < obs.length) {\n        // Swap-and-pop: move last observer into this slot\n        const last = obs.pop()!;\n        const lastSlot = obsSlots.pop()!;\n        if (index < obs.length) {\n          obs[index] = last;\n          obsSlots[index] = lastSlot;\n          // Update the swapped observer's _sourceSlots to point to new index\n          if (last._sourceSlots) {\n            last._sourceSlots[lastSlot] = index;\n          }\n        }\n      }\n    }\n    computation._sources = null;\n    computation._sourceSlots = null;\n  }\n}\n\n/** @internal - Run a computation with proper Listener tracking */\nexport function runComputation<T>(computation: Computation<T>): T | undefined {\n  const prevListener = Listener;\n  const prevOwner = Owner;\n\n  cleanupSources(computation);\n  Listener = computation;\n  Owner = computation._owner;\n\n  try {\n    const value = computation._fn(computation._value as any);\n    computation._value = value;\n    computation._state = 0;\n\n    const computed = (computation as any)._computed as Computed<T> | undefined;\n    if (computed) {\n      computed._value = value as T;\n      computed._state = 0;\n    }\n\n    return value;\n  } finally {\n    Listener = prevListener;\n    Owner = prevOwner;\n  }\n}\n\n/** @internal */\nfunction recompute<T>(computed: Computed<T>): void {\n  const computation = (computed as any)._computation as Computation<T>;\n  if (!computation?._fn) {\n    return;\n  }\n  runComputation(computation);\n}\n\n/**\n * Set the value of a signal, notifying dependents\n */\nexport function set<T>(signal: Signal<T>, value: T): T {\n  const comparator = signal._comparator;\n  if (comparator?.(signal._value, value)) {\n    return value;\n  }\n  signal._value = value;\n  if (signal._observers !== null) {\n    scheduleUpdate(signal);\n  }\n  return value;\n}\n\n/**\n * Update a signal's value using a function of the previous value\n */\nexport function update<T>(signal: Signal<T>, fn: (prev: T) => T): T {\n  const value = fn(signal._value);\n  return set(signal, value);\n}\n\n/**\n * Read a signal's value without registering a dependency\n */\nexport function peek<T>(signal: Signal<T>): T {\n  return signal._value;\n}\n\n/** @internal - Propagate stale state through computed/memo observers */\nfunction markDownstream(node: { _observers: Computation<any>[] | null }): void {\n  const observers = node._observers;\n  if (!observers) {\n    return;\n  }\n\n  for (let i = 0; i < observers.length; i++) {\n    const observer = observers[i]!;\n    if (observer._state !== 0) {\n      continue;\n    }\n\n    observer._state = 1;\n\n    const computed = (observer as any)._computed as Computed<any> | undefined;\n    if (computed) {\n      computed._state = 1;\n      markDownstream(computed);\n    }\n\n    if (observer._user) {\n      if (Pending === null) {\n        Pending = [];\n      }\n      Pending.push(observer);\n    }\n  }\n}\n\n/** @internal */\nfunction scheduleUpdate<T>(signal: Signal<T>): void {\n  const observers = signal._observers;\n  if (observers === null) {\n    return;\n  }\n\n  for (let i = 0; i < observers.length; i++) {\n    const observer = observers[i]!;\n    if (observer._state === 0) {\n      observer._state = 1;\n\n      const computed = (observer as any)._computed as any;\n      if (computed) {\n        computed._state = 1;\n        // Propagate stale state through downstream observers of this computed\n        markDownstream(computed);\n      }\n\n      if (Pending === null) {\n        Pending = [];\n      }\n      Pending.push(observer);\n    }\n  }\n\n  // Only flush if not in a batch\n  if (Updates === null) {\n    flushUpdates();\n  }\n}\n\n/** @internal */\nfunction flushUpdates(): void {\n  const updates = Pending;\n  Pending = null;\n  if (updates === null) {\n    return;\n  }\n\n  for (let i = 0; i < updates.length; i++) {\n    const computation = updates[i]!;\n\n    if (computation._user && computation._state === 1) {\n      runComputation(computation);\n    }\n    // Non-user computations (memos) stay stale for lazy re-evaluation.\n    // Don't force _state=1 here — recompute() may have already resolved it to 0.\n  }\n  Updates = null;\n}\n\n/**\n * Create a derived reactive signal (computed value)\n */\nexport function memo<T>(fn: () => T): Computed<T> {\n  const computed: Computed<T> = {\n    _fn: fn,\n    _value: undefined as T,\n    _observers: null,\n    _observerSlots: null,\n    _sources: null,\n    _sourceSlots: null,\n    _state: 1,\n  } as Computed<T>;\n\n  const computation: Computation<T> = {\n    _fn: fn as EffectFunction<T>,\n    _value: undefined,\n    _sources: null,\n    _sourceSlots: null,\n    _observers: null,\n    _observerSlots: null,\n    _owner: Owner,\n    _cleanups: null,\n    _context: null,\n    _suspense: null,\n    _user: false,\n    _pure: true,\n    _state: 1,\n    _updatedAt: null,\n  };\n\n  // Link computed and computation bidirectionally\n  (computed as any)._computation = computation;\n  (computation as any)._computed = computed;\n\n  // Make computed callable and proxy all properties to computed\n  const callable = (() => {\n    if (computed._state === 1) {\n      recompute(computed);\n    }\n    return computed._value;\n  }) as Computed<T>;\n\n  // Proxy all properties to computed so they stay in sync\n  Object.defineProperty(callable, \"_state\", {\n    get() {\n      return computed._state;\n    },\n    set(v: 0 | 1 | 2) {\n      computed._state = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_value\", {\n    get() {\n      return computed._value;\n    },\n    set(v: T) {\n      computed._value = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_observers\", {\n    get() {\n      return computed._observers;\n    },\n    set(v: any) {\n      computed._observers = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_observerSlots\", {\n    get() {\n      return computed._observerSlots;\n    },\n    set(v: any) {\n      computed._observerSlots = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_sources\", {\n    get() {\n      return computed._sources;\n    },\n    set(v: any) {\n      computed._sources = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_sourceSlots\", {\n    get() {\n      return computed._sourceSlots;\n    },\n    set(v: any) {\n      computed._sourceSlots = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_fn\", {\n    get() {\n      return computed._fn;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n  Object.defineProperty(callable, \"_computation\", {\n    get() {\n      return (computed as any)._computation;\n    },\n    set(v: any) {\n      (computed as any)._computation = v;\n    },\n    enumerable: true,\n    configurable: true,\n  });\n\n  // Initial computation\n  recompute(computed);\n\n  return callable;\n}\n\n/**\n * Execute a function without tracking signal dependencies\n */\nexport function untrack<T>(fn: () => T): T {\n  const prevListener = Listener;\n  Listener = null;\n  try {\n    return fn();\n  } finally {\n    Listener = prevListener;\n  }\n}\n\n/**\n * Batch multiple signal updates into a single reactive cycle\n */\nexport function batch(fn: () => void): void {\n  const prevUpdates = Updates;\n  const prevPending = Pending;\n  Updates = [];\n  Pending = [];\n  try {\n    fn();\n  } finally {\n    // Collect all pending updates\n    if (prevPending !== null && prevPending.length > 0) {\n      Pending = prevPending.concat(Pending);\n    }\n    Updates = prevUpdates;\n    // Flush after batch completes\n    flushUpdates();\n  }\n}\n\n/**\n * Create a reactive root context\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const prevOwner = Owner;\n  const prevListener = Listener;\n  const root: OwnerType = {\n    _owned: null,\n    _cleanups: null,\n    _owner: prevOwner,\n    _context: null,\n  };\n  Owner = root;\n  Listener = null;\n\n  try {\n    return fn(() => cleanRoot(root));\n  } finally {\n    Owner = prevOwner;\n    Listener = prevListener;\n  }\n}\n\n/** @internal */\nfunction cleanRoot(root: OwnerType): void {\n  if (root._cleanups !== null) {\n    const cleanups = root._cleanups;\n    root._cleanups = null;\n    // Run cleanups in reverse order (LIFO)\n    for (let i = cleanups.length - 1; i >= 0; i--) {\n      cleanups[i]!();\n    }\n  }\n  if (root._owned !== null) {\n    const owned = root._owned;\n    root._owned = null;\n    for (let i = 0; i < owned.length; i++) {\n      cleanNode(owned[i]!);\n    }\n  }\n}\n\n/**\n * Register a cleanup callback to run when the owner is disposed\n */\nexport function onCleanup(fn: () => void): void {\n  if (Owner === null) {\n    return;\n  }\n  if (Owner._cleanups === null) {\n    Owner._cleanups = [];\n  }\n  Owner._cleanups.push(fn);\n}\n\n/** @internal */\nexport function cleanNode(node: Computation<any> | OwnerType): void {\n  if (\"_cleanups\" in node && node._cleanups !== null) {\n    const cleanups = node._cleanups;\n    node._cleanups = null;\n    // Run cleanups in reverse order (LIFO)\n    for (let i = cleanups.length - 1; i >= 0; i--) {\n      cleanups[i]!();\n    }\n  }\n  if (\"_owned\" in node && node._owned !== null) {\n    const owned = node._owned;\n    node._owned = null;\n    for (let i = 0; i < owned.length; i++) {\n      cleanNode(owned[i]!);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/signal/signal.d.cts

@@ -0,0 +1,44 @@
+import { Computed, Owner as Owner$1, Signal, SignalOptions } from "../types.cjs";
+
+//#region src/signal/signal.d.ts
+/** @internal */
+declare let Owner: Owner$1 | null;
+/**
+ * Create a reactive signal with an initial value
+ */
+declare function sig<T>(initial: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Read the value of a signal, registering a dependency if inside a reactive context
+ */
+declare function val<T>(signal: Signal<T> | Computed<T>): T;
+/**
+ * Set the value of a signal, notifying dependents
+ */
+declare function set<T>(signal: Signal<T>, value: T): T;
+/**
+ * Update a signal's value using a function of the previous value
+ */
+declare function update<T>(signal: Signal<T>, fn: (prev: T) => T): T;
+/**
+ * Read a signal's value without registering a dependency
+ */
+declare function peek<T>(signal: Signal<T>): T;
+/**
+ * Create a derived reactive signal (computed value)
+ */
+declare function memo<T>(fn: () => T): Computed<T>;
+/**
+ * Execute a function without tracking signal dependencies
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Batch multiple signal updates into a single reactive cycle
+ */
+declare function batch(fn: () => void): void;
+/**
+ * Create a reactive root context
+ */
+declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+//#endregion
+export { Owner, batch, createRoot, memo, peek, set, sig, untrack, update, val };
+//# sourceMappingURL=signal.d.cts.map

package/dist/signal/signal.d.mts

@@ -0,0 +1,44 @@
+import { Computed, Owner as Owner$1, Signal, SignalOptions } from "../types.mjs";
+
+//#region src/signal/signal.d.ts
+/** @internal */
+declare let Owner: Owner$1 | null;
+/**
+ * Create a reactive signal with an initial value
+ */
+declare function sig<T>(initial: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Read the value of a signal, registering a dependency if inside a reactive context
+ */
+declare function val<T>(signal: Signal<T> | Computed<T>): T;
+/**
+ * Set the value of a signal, notifying dependents
+ */
+declare function set<T>(signal: Signal<T>, value: T): T;
+/**
+ * Update a signal's value using a function of the previous value
+ */
+declare function update<T>(signal: Signal<T>, fn: (prev: T) => T): T;
+/**
+ * Read a signal's value without registering a dependency
+ */
+declare function peek<T>(signal: Signal<T>): T;
+/**
+ * Create a derived reactive signal (computed value)
+ */
+declare function memo<T>(fn: () => T): Computed<T>;
+/**
+ * Execute a function without tracking signal dependencies
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Batch multiple signal updates into a single reactive cycle
+ */
+declare function batch(fn: () => void): void;
+/**
+ * Create a reactive root context
+ */
+declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+//#endregion
+export { Owner, batch, createRoot, memo, peek, set, sig, untrack, update, val };
+//# sourceMappingURL=signal.d.mts.map