@zeix/cause-effect 0.17.2 → 0.17.3

package/types/src/classes/computed.d.ts

@@ -1,8 +1,11 @@
-import { type Cleanup, type HookCallback, type WatchHook } from '../system';
+import { type SignalOptions } from '../system';
 type Computed<T extends {}> = {
     readonly [Symbol.toStringTag]: 'Computed';
     get(): T;
 };
+type ComputedOptions<T extends {}> = SignalOptions<T> & {
+    initialValue?: T;
+};
 type MemoCallback<T extends {} & {
     then?: undefined;
 }> = (oldValue: T) => T;
@@ -14,18 +17,14 @@ declare const TYPE_COMPUTED: "Computed";
  * Create a new memoized signal for a synchronous function.
  *
  * @since 0.17.0
+ * @param {MemoCallback<T>} callback - Callback function to compute the memoized value
+ * @param {T} [initialValue = UNSET] - Initial value of the signal
+ * @throws {InvalidCallbackError} If the callback is not an sync function
+ * @throws {InvalidSignalValueError} If the initial value is not valid
  */
 declare class Memo<T extends {}> {
     #private;
-    /**
-     * Create a new memoized signal.
-     *
-     * @param {MemoCallback<T>} callback - Callback function to compute the memoized value
-     * @param {T} [initialValue = UNSET] - Initial value of the signal
-     * @throws {InvalidCallbackError} If the callback is not an sync function
-     * @throws {InvalidSignalValueError} If the initial value is not valid
-     */
-    constructor(callback: MemoCallback<T>, initialValue?: T);
+    constructor(callback: MemoCallback<T>, options?: ComputedOptions<T>);
     get [Symbol.toStringTag](): 'Computed';
     /**
      * Return the memoized value after computing it if necessary.
@@ -35,31 +34,19 @@ declare class Memo<T extends {}> {
      * @throws {Error} If an error occurs during computation
      */
     get(): T;
-    /**
-     * Register a callback to be called when HOOK_WATCH is triggered.
-     *
-     * @param {WatchHook} type - The type of hook to register the callback for; only HOOK_WATCH is supported
-     * @param {HookCallback} callback - The callback to register
-     * @returns {Cleanup} - A function to unregister the callback
-     */
-    on(type: WatchHook, callback: HookCallback): Cleanup;
 }
 /**
  * Create a new task signals that memoizes the result of an asynchronous function.
  *
  * @since 0.17.0
+ * @param {TaskCallback<T>} callback - The asynchronous function to compute the memoized value
+ * @param {T} [initialValue = UNSET] - Initial value of the signal
+ * @throws {InvalidCallbackError} If the callback is not an async function
+ * @throws {InvalidSignalValueError} If the initial value is not valid
  */
 declare class Task<T extends {}> {
     #private;
-    /**
-     * Create a new task signal for an asynchronous function.
-     *
-     * @param {TaskCallback<T>} callback - The asynchronous function to compute the memoized value
-     * @param {T} [initialValue = UNSET] - Initial value of the signal
-     * @throws {InvalidCallbackError} If the callback is not an async function
-     * @throws {InvalidSignalValueError} If the initial value is not valid
-     */
-    constructor(callback: TaskCallback<T>, initialValue?: T);
+    constructor(callback: TaskCallback<T>, options?: ComputedOptions<T>);
     get [Symbol.toStringTag](): 'Computed';
     /**
      * Return the memoized value after executing the async function if necessary.
@@ -69,22 +56,15 @@ declare class Task<T extends {}> {
      * @throws {Error} If an error occurs during computation
      */
     get(): T;
-    /**
-     * Register a callback to be called when HOOK_WATCH is triggered.
-     *
-     * @param {WatchHook} type - The type of hook to register the callback for; only HOOK_WATCH is supported
-     * @param {HookCallback} callback - The callback to register
-     * @returns {Cleanup} - A function to unregister the callback
-     */
-    on(type: WatchHook, callback: HookCallback): Cleanup;
 }
 /**
  * Create a derived signal from existing signals
  *
  * @since 0.9.0
  * @param {MemoCallback<T> | TaskCallback<T>} callback - Computation callback function
+ * @param {ComputedOptions<T>} options - Optional configuration
  */
-declare const createComputed: <T extends {}>(callback: TaskCallback<T> | MemoCallback<T>, initialValue?: T) => Task<T> | Memo<T>;
+declare const createComputed: <T extends {}>(callback: TaskCallback<T> | MemoCallback<T>, options?: ComputedOptions<T>) => Task<T> | Memo<T>;
 /**
  * Check if a value is a computed signal
  *
@@ -111,4 +91,4 @@ declare const isMemoCallback: <T extends {} & {
  * @returns {boolean} - True if value is an async callback, false otherwise
  */
 declare const isTaskCallback: <T extends {}>(value: unknown) => value is TaskCallback<T>;
-export { TYPE_COMPUTED, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, Task, type Computed, type MemoCallback, type TaskCallback, };
+export { TYPE_COMPUTED, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, Task, type Computed, type ComputedOptions, type MemoCallback, type TaskCallback, };

package/types/src/classes/list.d.ts

@@ -1,15 +1,18 @@
 import { type UnknownArray } from '../diff';
-import { type Cleanup, type Hook, type HookCallback } from '../system';
+import { type SignalOptions } from '../system';
 import { DerivedCollection } from './collection';
 import { State } from './state';
 type ArrayToRecord<T extends UnknownArray> = {
     [key: string]: T extends Array<infer U extends {}> ? U : never;
 };
 type KeyConfig<T> = string | ((item: T) => string);
+type ListOptions<T extends {}> = SignalOptions<T> & {
+    keyConfig?: KeyConfig<T>;
+};
 declare const TYPE_LIST: "List";
 declare class List<T extends {}> {
     #private;
-    constructor(initialValue: T[], keyConfig?: KeyConfig<T>);
+    constructor(initialValue: T[], options?: ListOptions<T>);
     get [Symbol.toStringTag](): 'List';
     get [Symbol.isConcatSpreadable](): true;
     [Symbol.iterator](): IterableIterator<State<T>>;
@@ -26,9 +29,8 @@ declare class List<T extends {}> {
     remove(keyOrIndex: string | number): void;
     sort(compareFn?: (a: T, b: T) => number): void;
     splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    on(type: Hook, callback: HookCallback): Cleanup;
-    deriveCollection<R extends {}>(callback: (sourceValue: T) => R): DerivedCollection<R, T>;
-    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T) => R, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
 }
 /**
  * Check if the provided value is a List instance
@@ -38,4 +40,4 @@ declare class List<T extends {}> {
  * @returns {boolean} - True if the value is a List instance, false otherwise
  */
 declare const isList: <T extends {}>(value: unknown) => value is List<T>;
-export { isList, List, TYPE_LIST, type ArrayToRecord, type KeyConfig };
+export { isList, List, TYPE_LIST, type ArrayToRecord, type KeyConfig, type ListOptions, };

package/types/src/classes/ref.d.ts

@@ -1,22 +1,17 @@
-import { type Guard } from '../errors';
-import { type Cleanup, type HookCallback, type WatchHook } from '../system';
+import { type SignalOptions } from '../system';
 declare const TYPE_REF = "Ref";
 /**
  * Create a new ref signal.
  *
  * @since 0.17.1
+ * @param {T} value - Reference to external object
+ * @param {Guard<T>} guard - Optional guard function to validate the value
+ * @throws {NullishSignalValueError} - If the value is null or undefined
+ * @throws {InvalidSignalValueError} - If the value is invalid
  */
 declare class Ref<T extends {}> {
     #private;
-    /**
-     * Create a new ref signal.
-     *
-     * @param {T} value - Reference to external object
-     * @param {Guard<T>} guard - Optional guard function to validate the value
-     * @throws {NullishSignalValueError} - If the value is null or undefined
-     * @throws {InvalidSignalValueError} - If the value is invalid
-     */
-    constructor(value: T, guard?: Guard<T>);
+    constructor(value: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): string;
     /**
      * Get the value of the ref signal.
@@ -28,21 +23,13 @@ declare class Ref<T extends {}> {
      * Notify watchers of relevant changes in the external reference.
      */
     notify(): void;
-    /**
-     * Register a callback to be called when HOOK_WATCH is triggered.
-     *
-     * @param {WatchHook} type - The type of hook to register the callback for; only HOOK_WATCH is supported
-     * @param {HookCallback} callback - The callback to register
-     * @returns {Cleanup} - A function to unregister the callback
-     */
-    on(type: WatchHook, callback: HookCallback): Cleanup;
 }
 /**
  * Check if the provided value is a Ref instance
  *
  * @since 0.17.1
  * @param {unknown} value - Value to check
- * @returns {boolean} - True if the value is a Ref instance, false otherwise
+ * @returns {boolean} - Whether the value is a Ref instance
  */
 declare const isRef: <T extends {}>(value: unknown) => value is Ref<T>;
 export { TYPE_REF, Ref, isRef };

package/types/src/classes/state.d.ts

@@ -1,20 +1,16 @@
-import { type Cleanup, type HookCallback, type WatchHook } from '../system';
+import { type SignalOptions } from '../system';
 declare const TYPE_STATE: "State";
 /**
  * Create a new state signal.
  *
  * @since 0.17.0
+ * @param {T} initialValue - Initial value of the state
+ * @throws {NullishSignalValueError} - If the initial value is null or undefined
+ * @throws {InvalidSignalValueError} - If the initial value is invalid
  */
 declare class State<T extends {}> {
     #private;
-    /**
-     * Create a new state signal.
-     *
-     * @param {T} initialValue - Initial value of the state
-     * @throws {NullishSignalValueError} - If the initial value is null or undefined
-     * @throws {InvalidSignalValueError} - If the initial value is invalid
-     */
-    constructor(initialValue: T);
+    constructor(initialValue: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): string;
     /**
      * Get the current value of the state signal.
@@ -41,14 +37,6 @@ declare class State<T extends {}> {
      * @throws {InvalidSignalValueError} - If the initial value is invalid
      */
     update(updater: (oldValue: T) => T): void;
-    /**
-     * Register a callback to be called when HOOK_WATCH is triggered.
-     *
-     * @param {WatchHook} type - The type of hook to register the callback for; only HOOK_WATCH is supported
-     * @param {HookCallback} callback - The callback to register
-     * @returns {Cleanup} - A function to unregister the callback
-     */
-    on(type: WatchHook, callback: HookCallback): Cleanup;
 }
 /**
  * Check if the provided value is a State instance

package/types/src/classes/store.d.ts

@@ -1,22 +1,23 @@
 import { type UnknownRecord } from '../diff';
 import { type MutableSignal } from '../signal';
-import { type Cleanup, type Hook, type HookCallback } from '../system';
+import { type SignalOptions } from '../system';
 import type { List } from './list';
 import type { State } from './state';
 type Store<T extends UnknownRecord> = BaseStore<T> & {
     [K in keyof T]: T[K] extends readonly (infer U extends {})[] ? List<U> : T[K] extends UnknownRecord ? Store<T[K]> : State<T[K] & {}>;
 };
 declare const TYPE_STORE: "Store";
+/**
+ * Create a new store with the given initial value.
+ *
+ * @since 0.17.0
+ * @param {T} initialValue - The initial value of the store
+ * @throws {NullishSignalValueError} - If the initial value is null or undefined
+ * @throws {InvalidSignalValueError} - If the initial value is not an object
+ */
 declare class BaseStore<T extends UnknownRecord> {
     #private;
-    /**
-     * Create a new store with the given initial value.
-     *
-     * @param {T} initialValue - The initial value of the store
-     * @throws {NullishSignalValueError} - If the initial value is null or undefined
-     * @throws {InvalidSignalValueError} - If the initial value is not an object
-     */
-    constructor(initialValue: T);
+    constructor(initialValue: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): 'Store';
     get [Symbol.isConcatSpreadable](): boolean;
     [Symbol.iterator](): IterableIterator<[
@@ -30,16 +31,16 @@ declare class BaseStore<T extends UnknownRecord> {
     update(fn: (oldValue: T) => T): void;
     add<K extends keyof T & string>(key: K, value: T[K]): K;
     remove(key: string): void;
-    on(type: Hook, callback: HookCallback): Cleanup;
 }
 /**
  * Create a new store with deeply nested reactive properties
  *
  * @since 0.15.0
  * @param {T} initialValue - Initial object or array value of the store
+ * @param {SignalOptions<T>} options - Options for the store
  * @returns {Store<T>} - New store with reactive properties that preserves the original type T
  */
-declare const createStore: <T extends UnknownRecord>(initialValue: T) => Store<T>;
+declare const createStore: <T extends UnknownRecord>(initialValue: T, options?: SignalOptions<T>) => Store<T>;
 /**
  * Check if the provided value is a Store instance
  *

package/types/src/errors.d.ts

@@ -12,9 +12,6 @@ declare class InvalidCallbackError extends TypeError {
 declare class InvalidCollectionSourceError extends TypeError {
     constructor(where: string, value: unknown);
 }
-declare class InvalidHookError extends TypeError {
-    constructor(where: string, type: string);
-}
 declare class InvalidSignalValueError extends TypeError {
     constructor(where: string, value: unknown);
 }
@@ -24,8 +21,9 @@ declare class NullishSignalValueError extends TypeError {
 declare class ReadonlySignalError extends Error {
     constructor(what: string, value: unknown);
 }
+declare function assert(condition: unknown, msg?: string): asserts condition;
 declare const createError: (reason: unknown) => Error;
 declare const validateCallback: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
 declare const validateSignalValue: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
 declare const guardMutableSignal: <T extends {}>(what: string, value: unknown, signal: unknown) => signal is MutableSignal<T>;
-export { type Guard, CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidCollectionSourceError, InvalidHookError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, createError, validateCallback, validateSignalValue, guardMutableSignal, };
+export { type Guard, CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidCollectionSourceError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, assert, createError, validateCallback, validateSignalValue, guardMutableSignal, };

package/types/src/signal.d.ts

@@ -6,9 +6,10 @@ import type { UnknownRecord } from './diff';
 type Signal<T extends {}> = {
     get(): T;
 };
+type UnknownSignal = Signal<unknown & {}>;
 type MutableSignal<T extends {}> = T extends readonly (infer U extends {})[] ? List<U> : T extends UnknownRecord ? Store<T> : State<T>;
 type ReadonlySignal<T extends {}> = Computed<T>;
-type UnknownSignalRecord = Record<string, Signal<unknown & {}>>;
+type UnknownSignalRecord = Record<string, UnknownSignal>;
 type SignalValues<S extends UnknownSignalRecord> = {
     [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
 };
@@ -47,4 +48,4 @@ declare function createMutableSignal<T extends {}>(value: readonly T[]): List<T>
 declare function createMutableSignal<T extends {}>(value: T[]): List<T>;
 declare function createMutableSignal<T extends UnknownRecord>(value: T): Store<T>;
 declare function createMutableSignal<T extends {}>(value: T): State<T>;
-export { createMutableSignal, createSignal, isMutableSignal, isSignal, type MutableSignal, type ReadonlySignal, type Signal, type SignalValues, type UnknownSignalRecord, };
+export { createMutableSignal, createSignal, isMutableSignal, isSignal, type MutableSignal, type ReadonlySignal, type Signal, type SignalValues, type UnknownSignal, type UnknownSignalRecord, };

package/types/src/system.d.ts

@@ -1,58 +1,71 @@
+import { type Guard } from './errors';
+import type { UnknownSignal } from './signal';
 type Cleanup = () => void;
 type MaybeCleanup = Cleanup | undefined | void;
-type Hook = 'add' | 'change' | 'cleanup' | 'remove' | 'sort' | 'watch';
-type CleanupHook = 'cleanup';
-type WatchHook = 'watch';
-type HookCallback = (payload?: readonly string[]) => MaybeCleanup;
-type HookCallbacks = {
-    [K in Hook]?: Set<HookCallback>;
-};
 type Watcher = {
     (): void;
-    on(type: CleanupHook, cleanup: Cleanup): void;
+    run(): void;
+    onCleanup(cleanup: Cleanup): void;
     stop(): void;
 };
+type SignalOptions<T extends unknown & {}> = {
+    guard?: Guard<T>;
+    watched?: () => void;
+    unwatched?: () => void;
+};
 declare const UNSET: any;
-declare const HOOK_ADD = "add";
-declare const HOOK_CHANGE = "change";
-declare const HOOK_CLEANUP = "cleanup";
-declare const HOOK_REMOVE = "remove";
-declare const HOOK_SORT = "sort";
-declare const HOOK_WATCH = "watch";
 /**
- * Create a watcher to observe changes to a signal.
+ * Create a watcher to observe changes in signals.
  *
- * A watcher is a reaction function with onCleanup and stop methods
+ * A watcher combines push and pull reaction functions with onCleanup and stop methods
  *
- * @since 0.14.1
- * @param {() => void} react - Function to be called when the state changes
+ * @since 0.17.3
+ * @param {() => void} push - Function to be called when the state changes (push)
+ * @param {() => void} pull - Function to be called on demand from consumers (pull)
  * @returns {Watcher} - Watcher object with off and cleanup methods
  */
-declare const createWatcher: (react: () => void) => Watcher;
+declare const createWatcher: (push: () => void, pull: () => void) => Watcher;
+/**
+ * Run a function with signal reads in a non-tracking context.
+ *
+ * @param {() => void} callback - Callback
+ */
+declare const untrack: (callback: () => void) => void;
+declare const registerWatchCallbacks: (signal: UnknownSignal, watched: () => void, unwatched?: () => void) => void;
+/**
+ * Subscribe active watcher to a signal.
+ *
+ * @param {UnknownSignal} signal - Signal to subscribe to
+ * @returns {boolean} - true if the active watcher was subscribed,
+ *                      false if the watcher was already subscribed or there was no active watcher
+ */
+declare const subscribeTo: (signal: UnknownSignal) => boolean;
+declare const subscribeActiveWatcher: (watchers: Set<Watcher>) => boolean;
 /**
- * Subscribe by adding active watcher to the Set of watchers of a signal.
+ * Unsubscribe all watchers from a signal so it can be garbage collected.
  *
- * @param {Set<Watcher>} watchers - Watchers of the signal
- * @param {Set<HookCallback>} watchHookCallbacks - HOOK_WATCH callbacks of the signal
+ * @param {UnknownSignal} signal - Signal to unsubscribe from
+ * @returns {void}
  */
-declare const subscribeActiveWatcher: (watchers: Set<Watcher>, watchHookCallbacks?: Set<HookCallback>) => void;
+declare const unsubscribeAllFrom: (signal: UnknownSignal) => void;
 /**
  * Notify watchers of a signal change.
  *
- * @param {Set<Watcher>} watchers - Watchers of the signal
+ * @param {UnknownSignal} signal - Signal to notify watchers of
  * @returns {boolean} - Whether any watchers were notified
  */
+declare const notifyOf: (signal: UnknownSignal) => boolean;
 declare const notifyWatchers: (watchers: Set<Watcher>) => boolean;
 /**
  * Flush all pending reactions of enqueued watchers.
  */
-declare const flushPendingReactions: () => void;
+declare const flush: () => void;
 /**
  * Batch multiple signal writes.
  *
  * @param {() => void} callback - Function with multiple signal writes to be batched
  */
-declare const batchSignalWrites: (callback: () => void) => void;
+declare const batch: (callback: () => void) => void;
 /**
  * Run a function with signal reads in a tracking context (or temporarily untrack).
  *
@@ -61,21 +74,5 @@ declare const batchSignalWrites: (callback: () => void) => void;
  *                                    that might read signals (e.g., Web Components)
  * @param {() => void} run - Function to run the computation or effect
  */
-declare const trackSignalReads: (watcher: Watcher | false, run: () => void) => void;
-/**
- * Trigger a hook.
- *
- * @param {Set<HookCallback> | undefined} callbacks - Callbacks to be called when the hook is triggered
- * @param {readonly string[] | undefined} payload - Payload to be sent to listeners
- * @return {Cleanup | undefined} Cleanup function to be called when the hook is unmounted
- */
-declare const triggerHook: (callbacks: Set<HookCallback> | undefined, payload?: readonly string[]) => Cleanup | undefined;
-/**
- * Check whether a hook type is handled in a signal.
- *
- * @param {Hook} type - Type of hook to check
- * @param {T} handled - List of handled hook types
- * @returns {type is T[number]} - Whether the hook type is handled
- */
-declare const isHandledHook: <T extends readonly Hook[]>(type: Hook, handled: T) => type is T[number];
-export { type Cleanup, type MaybeCleanup, type Watcher, type Hook, type CleanupHook, type WatchHook, type HookCallback, type HookCallbacks, HOOK_ADD, HOOK_CHANGE, HOOK_CLEANUP, HOOK_REMOVE, HOOK_SORT, HOOK_WATCH, UNSET, createWatcher, subscribeActiveWatcher, notifyWatchers, flushPendingReactions, batchSignalWrites, trackSignalReads, triggerHook, isHandledHook, };
+declare const track: (watcher: Watcher | false, run: () => void) => void;
+export { type Cleanup, type MaybeCleanup, type Watcher, type SignalOptions, UNSET, createWatcher, registerWatchCallbacks, subscribeTo, subscribeActiveWatcher, unsubscribeAllFrom, notifyOf, notifyWatchers, flush, batch, track, untrack, };

package/src/classes/composite.ts

@@ -1,171 +0,0 @@
-import type { DiffResult, UnknownRecord } from '../diff'
-import { guardMutableSignal, InvalidHookError } from '../errors'
-import type { Signal } from '../signal'
-import {
-	batchSignalWrites,
-	type Cleanup,
-	createWatcher,
-	HOOK_ADD,
-	HOOK_CHANGE,
-	HOOK_REMOVE,
-	type HookCallback,
-	type HookCallbacks,
-	isHandledHook,
-	trackSignalReads,
-	triggerHook,
-	type Watcher,
-} from '../system'
-
-/* === Types === */
-
-type CompositeHook = 'add' | 'change' | 'remove'
-
-/* === Class Definitions === */
-
-class Composite<T extends UnknownRecord, S extends Signal<T[keyof T] & {}>> {
-	signals = new Map<string, S>()
-	#validate: <K extends keyof T & string>(
-		key: K,
-		value: unknown,
-	) => value is T[K] & {}
-	#create: <V extends T[keyof T] & {}>(value: V) => S
-	#watchers = new Map<string, Watcher>()
-	#hookCallbacks: HookCallbacks = {}
-	#batching = false
-
-	constructor(
-		values: T,
-		validate: <K extends keyof T & string>(
-			key: K,
-			value: unknown,
-		) => value is T[K] & {},
-		create: <V extends T[keyof T] & {}>(value: V) => S,
-	) {
-		this.#validate = validate
-		this.#create = create
-		this.change(
-			{
-				add: values,
-				change: {},
-				remove: {},
-				changed: true,
-			},
-			true,
-		)
-	}
-
-	#addWatcher(key: string): void {
-		const watcher = createWatcher(() => {
-			trackSignalReads(watcher, () => {
-				this.signals.get(key)?.get() // Subscribe to the signal
-				if (!this.#batching)
-					triggerHook(this.#hookCallbacks.change, [key])
-			})
-		})
-		this.#watchers.set(key, watcher)
-		watcher()
-	}
-
-	add<K extends keyof T & string>(key: K, value: T[K]): boolean {
-		if (!this.#validate(key, value)) return false
-
-		this.signals.set(key, this.#create(value))
-		if (this.#hookCallbacks.change?.size) this.#addWatcher(key)
-
-		if (!this.#batching) triggerHook(this.#hookCallbacks.add, [key])
-		return true
-	}
-
-	remove<K extends keyof T & string>(key: K): boolean {
-		const ok = this.signals.delete(key)
-		if (!ok) return false
-
-		const watcher = this.#watchers.get(key)
-		if (watcher) {
-			watcher.stop()
-			this.#watchers.delete(key)
-		}
-
-		if (!this.#batching) triggerHook(this.#hookCallbacks.remove, [key])
-		return true
-	}
-
-	change(changes: DiffResult, initialRun?: boolean): boolean {
-		this.#batching = true
-
-		// Additions
-		if (Object.keys(changes.add).length) {
-			for (const key in changes.add)
-				this.add(
-					key as Extract<keyof T, string>,
-					changes.add[key] as T[Extract<keyof T, string>] & {},
-				)
-
-			// Queue initial additions event to allow listeners to be added first
-			const notify = () =>
-				triggerHook(this.#hookCallbacks.add, Object.keys(changes.add))
-			if (initialRun) setTimeout(notify, 0)
-			else notify()
-		}
-
-		// Changes
-		if (Object.keys(changes.change).length) {
-			batchSignalWrites(() => {
-				for (const key in changes.change) {
-					const value = changes.change[key]
-					if (!this.#validate(key as keyof T & string, value))
-						continue
-
-					const signal = this.signals.get(key)
-					if (guardMutableSignal(`list item "${key}"`, value, signal))
-						signal.set(value)
-				}
-			})
-			triggerHook(this.#hookCallbacks.change, Object.keys(changes.change))
-		}
-
-		// Removals
-		if (Object.keys(changes.remove).length) {
-			for (const key in changes.remove)
-				this.remove(key as keyof T & string)
-			triggerHook(this.#hookCallbacks.remove, Object.keys(changes.remove))
-		}
-
-		this.#batching = false
-		return changes.changed
-	}
-
-	clear(): boolean {
-		const keys = Array.from(this.signals.keys())
-		this.signals.clear()
-		this.#watchers.clear()
-		triggerHook(this.#hookCallbacks.remove, keys)
-		return true
-	}
-
-	on(type: CompositeHook, callback: HookCallback): Cleanup {
-		if (!isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE]))
-			throw new InvalidHookError('Composite', type)
-
-		this.#hookCallbacks[type] ||= new Set()
-		this.#hookCallbacks[type].add(callback)
-		if (type === HOOK_CHANGE && !this.#watchers.size) {
-			this.#batching = true
-			for (const key of this.signals.keys()) this.#addWatcher(key)
-			this.#batching = false
-		}
-
-		return () => {
-			this.#hookCallbacks[type]?.delete(callback)
-			if (type === HOOK_CHANGE && !this.#hookCallbacks.change?.size) {
-				if (this.#watchers.size) {
-					for (const watcher of this.#watchers.values())
-						watcher.stop()
-					this.#watchers.clear()
-				}
-			}
-		}
-	}
-}
-
-export { Composite, type CompositeHook as CompositeListeners }

package/types/src/classes/composite.d.ts

@@ -1,15 +0,0 @@
-import type { DiffResult, UnknownRecord } from '../diff';
-import type { Signal } from '../signal';
-import { type Cleanup, type HookCallback } from '../system';
-type CompositeHook = 'add' | 'change' | 'remove';
-declare class Composite<T extends UnknownRecord, S extends Signal<T[keyof T] & {}>> {
-    #private;
-    signals: Map<string, S>;
-    constructor(values: T, validate: <K extends keyof T & string>(key: K, value: unknown) => value is T[K] & {}, create: <V extends T[keyof T] & {}>(value: V) => S);
-    add<K extends keyof T & string>(key: K, value: T[K]): boolean;
-    remove<K extends keyof T & string>(key: K): boolean;
-    change(changes: DiffResult, initialRun?: boolean): boolean;
-    clear(): boolean;
-    on(type: CompositeHook, callback: HookCallback): Cleanup;
-}
-export { Composite, type CompositeHook as CompositeListeners };