@zeix/cause-effect 0.12.3 → 0.13.0

package/lib/computed.ts

@@ -1,18 +1,25 @@
-import {
-	type MaybeSignal, type EffectCallbacks, type ComputedCallbacks,
-	resolve, UNSET
-} from './signal'
-import { isError, isObjectOfType, isPromise, toError } from './util'
+import { type Signal, match, UNSET } from './signal'
+import { CircularDependencyError, isAbortError, isAsyncFunction, isFunction, isObjectOfType, isPromise, toError } from './util'
 import { type Watcher, flush, notify, subscribe, watch } from './scheduler'
-import { effect } from './effect'
+import { type TapMatcher, type EffectMatcher, effect } from './effect'
 
 /* === Types === */
 
+export type ComputedMatcher<S extends Signal<{}>[], R extends {}> = {
+	signals: S,
+	abort?: AbortSignal
+	ok: (...values: {
+			[K in keyof S]: S[K] extends Signal<infer T> ? T : never
+		}) => R | Promise<R>
+	err?: (...errors: Error[]) => R | Promise<R>
+	nil?: () => R | Promise<R>
+}
+
 export type Computed<T extends {}> = {
     [Symbol.toStringTag]: 'Computed'
-    get: () => T
-    map: <U extends {}>(cb: ComputedCallbacks<U, [Computed<T>]>) => Computed<U>
-	match: (cb: EffectCallbacks<[Computed<T>]>) => void
+    get(): T
+    map<U extends {}>(fn: (v: T) => U | Promise<U>): Computed<U>
+	tap(matcher: TapMatcher<T> | ((v: T) => void | (() => void))): () => void
 }
 
 /* === Constants === */
@@ -35,20 +42,30 @@ const isEquivalentError = /*#__PURE__*/ (
  * Create a derived signal from existing signals
  * 
  * @since 0.9.0
- * @param {() => T} cb - compute callback or object of ok, nil, err callbacks to derive state
- * @param {U} maybeSignals - signals of functions using signals this values depends on
+ * @param {ComputedMatcher<S, T> | ((abort?: AbortSignal) => T | Promise<T>)} matcher - computed matcher or callback
  * @returns {Computed<T>} - Computed signal
  */
-export const computed = <T extends {}, U extends MaybeSignal<{}>[]>(
-	cb: ComputedCallbacks<T, U>,
-	...maybeSignals: U
+export const computed = <T extends {}, S extends Signal<{}>[] = []>(
+	matcher: ComputedMatcher<S, T> | ((abort?: AbortSignal) => T | Promise<T>)
 ): Computed<T> => {
-	const watchers: Watcher[] = []
+	const watchers: Set<Watcher> = new Set()
+	const m = isFunction(matcher) ? undefined : {
+			nil: () => UNSET,
+			err: (...errors: Error[]) => {
+				if (errors.length > 1) throw new AggregateError(errors)
+				else throw errors[0]
+			},
+			...matcher,
+		} as Required<ComputedMatcher<S, T>>
+	const fn = (m ? m.ok : matcher) as (abort?: AbortSignal) => T | Promise<T>
+
+	// Internal state
 	let value: T = UNSET
 	let error: Error | undefined
 	let dirty = true
-	let unchanged = false
+	let changed = false
 	let computing = false
+	let controller: AbortController | undefined
 
 	// Functions to update internal state
 	const ok = (v: T) => {
@@ -56,41 +73,76 @@ export const computed = <T extends {}, U extends MaybeSignal<{}>[]>(
 			value = v
 			dirty = false
 			error = undefined
-			unchanged = false
+			changed = true
 		}
 	}
 	const nil = () => {
-		unchanged = (UNSET === value)
+		changed = (UNSET !== value)
 		value = UNSET
 		error = undefined
 	}
 	const err = (e: unknown) => {
 		const newError = toError(e)
-		unchanged = isEquivalentError(newError, error)
+		changed = !isEquivalentError(newError, error)
 		value = UNSET
 		error = newError
 	}
+	const resolve = (v: T) => {
+		computing = false
+		controller = undefined
+		ok(v)
+		if (changed) notify(watchers)
+	}
+	const reject = (e: unknown) => {
+		computing = false
+		controller = undefined
+		err(e)
+		if (changed) notify(watchers)
+	}
+	const abort = () => {
+        computing = false
+        controller = undefined
+		compute() // retry
+    }
 
 	// Called when notified from sources (push)
-	const mark = () => {
+	const mark = (() => {
 		dirty = true
-		if (!unchanged) notify(watchers)
-	}
+		controller?.abort('Aborted because source signal changed')
+		if (watchers.size) {
+			if (changed) notify(watchers)
+		} else {
+			mark.cleanups.forEach((fn: () => void) => fn())
+			mark.cleanups.clear()
+		}
+	}) as Watcher
+	mark.cleanups = new Set()
 
 	// Called when requested by dependencies (pull)
 	const compute = () => watch(() => {
-		if (computing) throw new Error('Circular dependency in computed detected')
-		unchanged = true
+		if (computing) throw new CircularDependencyError('computed')
+		changed = false
+		if (isAsyncFunction(fn)) {
+			if (controller) return value // return current value until promise resolves
+			controller = new AbortController()
+			if (m) m.abort = m.abort instanceof AbortSignal
+			? AbortSignal.any([m.abort, controller.signal])
+			: controller.signal
+			controller.signal.addEventListener('abort', abort, { once: true })
+		}
+		let result: T | Promise<T>
 		computing = true
-		const result = resolve(maybeSignals, cb)
-		if (isPromise(result)) {
-			nil() // sync
-			result.then(v => {
-				ok(v) // async
-                notify(watchers)
-			}).catch(err)
-		} else if (null == result || UNSET === result) nil()
-		else if (isError(result)) err(result)
+		try {
+			result = m && m.signals.length
+				? match<S, T>(m)
+				: fn(controller?.signal)
+		} catch (e) {
+			isAbortError(e) ? nil() : err(e)
+			computing = false
+			return
+        }
+		if (isPromise(result)) result.then(resolve, reject)
+		else if (null == result || UNSET === result) nil()
 		else ok(result)
 		computing = false
 	}, mark)
@@ -116,23 +168,27 @@ export const computed = <T extends {}, U extends MaybeSignal<{}>[]>(
 		 * Create a computed signal from the current computed signal
 		 * 
 		 * @since 0.9.0
-		 * @param {ComputedCallbacks<U, [Computed<T>]>} cb - compute callback or object of ok, nil, err callbacks to map this value to new computed
+		 * @param {((v: T) => U | Promise<U>)} fn - computed callback
 		 * @returns {Computed<U>} - computed signal
 		 */
-		map: <U extends {}>(cb: ComputedCallbacks<U, [Computed<T>]>): Computed<U> =>
-			computed(cb, c),
+		map: <U extends {}>(fn: (v: T) => U | Promise<U>): Computed<U> =>
+			computed({
+				signals: [c],
+				ok: fn
+			}),
 
-		/**
+		/** 
 		 * Case matching for the computed signal with effect callbacks
 		 * 
-		 * @since 0.12.0
-		 * @param {EffectCallbacks[Computed<T>]} cb - effect callback or object of ok, nil, err callbacks to be executed when the computed changes
-		 * @returns {Computed<T>} - self, for chaining effect callbacks
+		 * @since 0.13.0
+		 * @param {TapMatcher<T> | ((v: T) => void | (() => void))} matcher - tap matcher or effect callback
+		 * @returns {() => void} - cleanup function for the effect
 		 */
-		match: (cb: EffectCallbacks<[Computed<T>]>): Computed<T> => {
-			effect(cb, c)
-			return c
-		}
+		tap: (matcher: TapMatcher<T> | ((v: T) => void | (() => void))): () => void =>
+			effect({
+				signals: [c],
+				...(isFunction(matcher) ? { ok: matcher } : matcher)
+			} as EffectMatcher<[Computed<T>]>)
 	}
 	return c
 }

package/lib/effect.d.ts

@@ -1,9 +1,22 @@
-import { type EffectCallbacks, type MaybeSignal } from './signal';
+import { type Signal } from './signal';
+export type TapMatcher<T extends {}> = {
+    ok: (value: T) => void | (() => void);
+    err?: (error: Error) => void | (() => void);
+    nil?: () => void | (() => void);
+};
+export type EffectMatcher<S extends Signal<{}>[]> = {
+    signals: S;
+    ok: (...values: {
+        [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
+    }) => void | (() => void);
+    err?: (...errors: Error[]) => void | (() => void);
+    nil?: () => void | (() => void);
+};
 /**
  * Define what happens when a reactive state changes
  *
  * @since 0.1.0
- * @param {() => void} cb - effect callback or object of ok, nil, err callbacks to be executed when a state changes
- * @param {U} maybeSignals - signals of functions using signals that should trigger the effect
+ * @param {EffectMatcher<S> | (() => void | (() => void))} matcher - effect matcher or callback
+ * @returns {() => void} - cleanup function for the effect
  */
-export declare function effect<U extends MaybeSignal<{}>[]>(cb: EffectCallbacks<U>, ...maybeSignals: U): void;
+export declare function effect<S extends Signal<{}>[]>(matcher: EffectMatcher<S> | (() => void | (() => void))): () => void;

package/lib/effect.ts

@@ -1,29 +1,61 @@
+import { type Signal, match } from './signal'
+import { CircularDependencyError, isFunction, toError } from './util'
+import { watch, type Watcher } from './scheduler'
 
-import { type EffectCallbacks, type MaybeSignal, resolve } from './signal'
-import { isError } from './util'
-import { watch } from './scheduler'
+/* === Types === */
 
-/* === Exported Function === */
+export type TapMatcher<T extends {}> = {
+	ok: (value: T) => void | (() => void)
+	err?: (error: Error) => void | (() => void)
+	nil?: () => void | (() => void)
+}
+
+export type EffectMatcher<S extends Signal<{}>[]> = {
+	signals: S
+	ok: (...values: {
+		[K in keyof S]: S[K] extends Signal<infer T> ? T : never
+	}) => void | (() => void)
+	err?: (...errors: Error[]) => void | (() => void)
+	nil?: () => void | (() => void)
+}
+
+/* === Exported Functions === */
 
 /**
  * Define what happens when a reactive state changes
  * 
  * @since 0.1.0
- * @param {() => void} cb - effect callback or object of ok, nil, err callbacks to be executed when a state changes
- * @param {U} maybeSignals - signals of functions using signals that should trigger the effect
+ * @param {EffectMatcher<S> | (() => void | (() => void))} matcher - effect matcher or callback
+ * @returns {() => void} - cleanup function for the effect
  */
-export function effect<U extends MaybeSignal<{}>[]>(
-	cb: EffectCallbacks<U>,
-	...maybeSignals: U
-): void {
+export function effect<S extends Signal<{}>[]>(
+	matcher: EffectMatcher<S> | (() => void | (() => void))
+): () => void {
+	const {
+		signals,
+		ok,
+		err = console.error,
+		nil = () => {}
+	} = isFunction(matcher)
+		? { signals: [] as unknown as S, ok: matcher }
+		: matcher
 	let running = false
-	const run = () => watch(() => {
-		if (running) throw new Error('Circular dependency in effect detected')
+	const run = (() => watch(() => {
+		if (running) throw new CircularDependencyError('effect')
 		running = true
-		const result = resolve(maybeSignals, cb)
-		if (isError(result))
-			console.error('Unhandled error in effect:', result)
+		let cleanup: void | (() => void) = undefined
+		try {
+			cleanup = match<S, void | (() => void)>({ signals, ok, err, nil }) as void | (() => void)
+		} catch (e) {
+			err(toError(e))
+		}
+		if (isFunction(cleanup)) run.cleanups.add(cleanup)
 		running = false
-    }, run)
+    }, run)) as Watcher
+	run.cleanups = new Set()
 	run()
-}
+	return () => {
+		run.cleanups.forEach((fn: () => void) => fn())
+		run.cleanups.clear()
+	}
+}

package/lib/scheduler.d.ts

@@ -1,18 +1,21 @@
 export type EnqueueDedupe = [Element, string];
-export type Watcher = () => void;
+export type Watcher = {
+    (): void;
+    cleanups: Set<() => void>;
+};
 export type Updater = <T>() => T | boolean | void;
 /**
- * Add active watcher to the array of watchers
+ * Add active watcher to the Set of watchers
  *
- * @param {Watcher[]} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - watchers of the signal
  */
-export declare const subscribe: (watchers: Watcher[]) => void;
+export declare const subscribe: (watchers: Set<Watcher>) => void;
 /**
  * Add watchers to the pending set of change notifications
  *
- * @param {Watcher[]} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - watchers of the signal
  */
-export declare const notify: (watchers: Watcher[]) => void;
+export declare const notify: (watchers: Set<Watcher>) => void;
 /**
  * Flush all pending changes to notify watchers
  */

package/lib/scheduler.ts

@@ -2,7 +2,11 @@
 
 export type EnqueueDedupe = [Element, string]
 
-export type Watcher = () => void
+export type Watcher = {
+	(): void,
+	cleanups: Set<() => void>
+}
+
 export type Updater = <T>() => T | boolean | void
 
 /* === Internal === */
@@ -38,25 +42,30 @@ queueMicrotask(updateDOM)
 /* === Exported Functions === */
 
 /**
- * Add active watcher to the array of watchers
+ * Add active watcher to the Set of watchers
  * 
- * @param {Watcher[]} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - watchers of the signal
  */
-export const subscribe = (watchers: Watcher[]) => {
+export const subscribe = (watchers: Set<Watcher>) => {
 	// if (!active) console.warn('Calling .get() outside of a reactive context')
-	if (active && !watchers.includes(active)) {
-		watchers.push(active)
+	if (active && !watchers.has(active)) {
+		const watcher = active
+		watchers.add(watcher)
+		active.cleanups.add(() => {
+			watchers.delete(watcher)
+		})
 	}
 }
 
 /**
  * Add watchers to the pending set of change notifications
  * 
- * @param {Watcher[]} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - watchers of the signal
  */
-export const notify = (watchers: Watcher[]) => {
+export const notify = (watchers: Set<Watcher>) => {
 	for (const mark of watchers) {
-        batchDepth ? pending.add(mark) : mark()
+        if (batchDepth) pending.add(mark)
+		else mark()
     }
 }
 

package/lib/signal.d.ts

@@ -1,53 +1,44 @@
 import { type State } from "./state";
 import { type Computed } from "./computed";
 type Signal<T extends {}> = State<T> | Computed<T>;
-type MaybeSignal<T extends {}> = Signal<T> | T | (() => T | Promise<T>);
-type InferMaybeSignalType<T> = T extends Signal<infer U> ? U : T extends (() => infer U) ? U : T;
-type OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
-    [K in keyof U]: InferMaybeSignalType<U[K]>;
-}) => T | Promise<T> | Error;
-type NilCallback<T> = () => T | Promise<T> | Error;
-type ErrCallback<T> = (...errors: Error[]) => T | Promise<T> | Error;
-type ComputedCallbacks<T extends {}, U extends MaybeSignal<{}>[]> = OkCallback<T, U> | {
-    ok: OkCallback<T, U>;
-    nil?: NilCallback<T>;
-    err?: ErrCallback<T>;
-};
-type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
-    ok: OkCallback<void, U>;
-    nil?: NilCallback<void>;
-    err?: ErrCallback<void>;
-};
-type CallbackReturnType<T> = T | Promise<T> | Error | void;
+type MaybeSignal<T extends {}> = Signal<T> | T | (() => T) | ((abort: AbortSignal) => Promise<T>);
 declare const UNSET: any;
 /**
  * Check whether a value is a Signal or not
  *
  * @since 0.9.0
- * @param {any} value - value to check
+ * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
 declare const isSignal: <T extends {}>(value: any) => value is Signal<T>;
+/**
+ * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
+ *
+ * @since 0.12.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
+ */
+declare const isComputedCallback: <T extends {}>(value: unknown) => value is (abort?: AbortSignal) => T | Promise<T>;
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
  * @since 0.9.6
  * @param {MaybeSignal<T>} value - value to convert to a Signal
- * @param memo
  * @returns {Signal<T>} - converted Signal
  */
-declare const toSignal: <T extends {}>(value: MaybeSignal<T> | ComputedCallbacks<T, []>) => Signal<T>;
+declare const toSignal: <T extends {}>(value: MaybeSignal<T>) => Signal<T>;
 /**
  * Resolve signals or functions using signals and apply callbacks based on the results
  *
- * @since 0.12.0
- * @param {U} maybeSignals - dependency signals (or functions using signals)
- * @param {Record<string, (...args) => CallbackReturnType<T>} cb - object of ok, nil, err callbacks or just ok callback
- * @returns {CallbackReturnType<T>} - result of chosen callback
+ * @since 0.13.0
+ * @param {SignalMatcher<S, R>} matcher - SignalMatcher to match
+ * @returns {R | Promise<R>} - result of the matched callback
  */
-declare const resolve: <T, U extends MaybeSignal<{}>[]>(maybeSignals: U, cb: OkCallback<T | Promise<T>, U> | {
-    ok: OkCallback<T | Promise<T>, U>;
-    nil?: NilCallback<T>;
-    err?: ErrCallback<T>;
-}) => CallbackReturnType<T>;
-export { type Signal, type MaybeSignal, type InferMaybeSignalType, type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType, UNSET, isSignal, toSignal, resolve, };
+declare const match: <S extends Signal<{}>[], R>(matcher: {
+    signals: S;
+    abort?: AbortSignal;
+    ok: ((...values: { [K in keyof S]: S[K] extends Signal<infer T> ? T : never; }) => R | Promise<R>);
+    err: ((...errors: Error[]) => R | Promise<R>);
+    nil: (abort?: AbortSignal) => R | Promise<R>;
+}) => R | Promise<R>;
+export { type Signal, type MaybeSignal, UNSET, isSignal, isComputedCallback, toSignal, match, };

package/lib/signal.ts

@@ -1,127 +1,101 @@
 import { type State, isState, state } from "./state"
 import { type Computed, computed, isComputed } from "./computed"
-import { isFunction, toError } from "./util"
+import { isAbortError, isFunction, toError } from "./util"
 
 /* === Types === */
 
 type Signal<T extends {}> = State<T> | Computed<T>
-type MaybeSignal<T extends {}> = Signal<T> | T | (() => T | Promise<T>)
-type InferMaybeSignalType<T> = T extends Signal<infer U> ? U :
-	T extends (() => infer U) ? U :
-	T
-
-type OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
-	[K in keyof U]: InferMaybeSignalType<U[K]>
-}) => T | Promise<T> | Error
-type NilCallback<T> = () => T | Promise<T> | Error
-type ErrCallback<T> = (...errors: Error[]) => T | Promise<T> | Error
-
-type ComputedCallbacks<T extends {}, U extends MaybeSignal<{}>[]> = OkCallback<T, U> | {
-	ok: OkCallback<T, U>,
-    nil?: NilCallback<T>,
-    err?: ErrCallback<T>
-}
-
-type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
-	ok: OkCallback<void, U>,
-	nil?: NilCallback<void>,
-	err?: ErrCallback<void>
-}
-
-type CallbackReturnType<T> = T | Promise<T> | Error | void
+type MaybeSignal<T extends {}> = Signal<T> | T | (() => T) | ((abort: AbortSignal) => Promise<T>)
 
 /* === Constants === */
 
 const UNSET: any = Symbol()
 
-/* === Private Functions === */
-
-const isComputedCallbacks = /*#__PURE__*/ <T extends {}>(value: unknown): value is ComputedCallbacks<T, []> =>
-	(isFunction(value) && !value.length)
-		|| (typeof value === 'object' && value !== null && 'ok' in value && isFunction(value.ok))
-
 /* === Exported Functions === */
 
 /**
  * Check whether a value is a Signal or not
  * 
  * @since 0.9.0
- * @param {any} value - value to check
+ * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
 const isSignal = /*#__PURE__*/ <T extends {}>(value: any): value is Signal<T> =>
 	isState(value) || isComputed(value)
 
+/**
+ * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
+ * 
+ * @since 0.12.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
+ */
+const isComputedCallback = /*#__PURE__*/ <T extends {}>(
+	value: unknown
+): value is (abort?: AbortSignal) => T | Promise<T> =>
+	isFunction(value) && value.length < 2
+
 /**
  * Convert a value to a Signal if it's not already a Signal
  * 
  * @since 0.9.6
  * @param {MaybeSignal<T>} value - value to convert to a Signal
- * @param memo 
  * @returns {Signal<T>} - converted Signal
  */
 const toSignal = /*#__PURE__*/ <T extends {}>(
-	value: MaybeSignal<T> | ComputedCallbacks<T, []>
-): Signal<T> =>
-	isSignal<T>(value) ? value
-		: isComputedCallbacks<T>(value) ? computed(value)
-		: state(value as T)
+	value: MaybeSignal<T>
+): Signal<T> => isSignal<T>(value) ? value
+	: isComputedCallback<T>(value) ? computed(value)
+	: state(value as T)
 
 
 /**
  * Resolve signals or functions using signals and apply callbacks based on the results
  * 
- * @since 0.12.0
- * @param {U} maybeSignals - dependency signals (or functions using signals)
- * @param {Record<string, (...args) => CallbackReturnType<T>} cb - object of ok, nil, err callbacks or just ok callback
- * @returns {CallbackReturnType<T>} - result of chosen callback
+ * @since 0.13.0
+ * @param {SignalMatcher<S, R>} matcher - SignalMatcher to match
+ * @returns {R | Promise<R>} - result of the matched callback
  */
-const resolve = <T, U extends MaybeSignal<{}>[]>(
-	maybeSignals: U,
-	cb: OkCallback<T | Promise<T>, U> | {
-		ok: OkCallback<T | Promise<T>, U>
-		nil?: NilCallback<T>
-		err?: ErrCallback<T>
+const match = <S extends Signal<{}>[], R>(
+	matcher: {
+		signals: S,
+		abort?: AbortSignal,
+		ok: ((...values: {
+				[K in keyof S]: S[K] extends Signal<infer T> ? T : never
+			}) => R | Promise<R>),
+		err: ((...errors: Error[]) => R | Promise<R>),
+		nil: (abort?: AbortSignal) => R | Promise<R>
 	}
-): CallbackReturnType<T> => {
-	const { ok, nil, err } = isFunction(cb)
-		? { ok: cb }
-		: cb as {
-			ok: OkCallback<T | Promise<T>, U>
-			nil?: NilCallback<T>
-			err?: ErrCallback<T>
-		}
-	const values = [] as {
-		[K in keyof U]: InferMaybeSignalType<U[K]>
-	}
-    const errors: Error[] = []
-    let hasUnset = false
+): R | Promise<R> => {
+	const { signals, abort, ok, err, nil } = matcher
 
-    for (let i = 0; i < maybeSignals.length; i++) {
-		const s = maybeSignals[i]
+	const errors: Error[] = []
+	let suspense = false
+	const values = signals.map(signal => {
 		try {
-			const value = isSignal(s) ? s.get() : isFunction(s) ? s() : s
-			if (value === UNSET) hasUnset = true
-			values[i] = value as InferMaybeSignalType<typeof s>
+			const value = signal.get()
+			if (value === UNSET) suspense = true
+			return value
 		} catch (e) {
+			if (isAbortError(e)) throw e
 			errors.push(toError(e))
 		}
-    }
-
-	let result: CallbackReturnType<T> = undefined
-    try {
-		if (hasUnset && nil) result = nil()
-		else if (errors.length) result = err ? err(...errors) : errors[0]
-		else if (!hasUnset) result = ok(...values) as CallbackReturnType<T>
-    } catch (e) {
-		result = toError(e)
-		if (err) result = err(result)
-    }
-	return result
+	}) as {
+		[K in keyof S]: S[K] extends Signal<infer T extends {}> ? T : never
+	}
+	
+	try {
+		return suspense ? nil(abort)
+			: errors.length ? err(...errors)
+			: ok(...values)
+	} catch (e) {
+		if (isAbortError(e)) throw e
+		const error = toError(e)
+		return err(error)
+	}
 }
 
 export {
-	type Signal, type MaybeSignal, type InferMaybeSignalType,
-	type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType,
-    UNSET, isSignal, toSignal, resolve,
+	type Signal, type MaybeSignal,
+    UNSET, isSignal, isComputedCallback, toSignal, match,
 }