@oscarpalmer/mora 0.38.0 → 0.39.0

package/dist/value/array.d.mts

@@ -1,5 +1,4 @@
 import { ReactiveArray, ReactiveOptions } from "../models.mjs";
-//#region src/value/array.d.ts
 /**
  * Create a reactive array from a function result
  *
@@ -23,5 +22,4 @@ export declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOp
  * @param options Reactivity options
  * @returns Reactive array
  */
-export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
-//#endregion
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/dist/value/array.mjs

@@ -1,17 +1,17 @@
-import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, NAME_MORA, PROPERTY_LENGTH, SYMBOL_STATE } from "../constants.mjs";
+import { MESSAGE_DEACTIVATED_ARRAY_FILTER, MESSAGE_DEACTIVATED_ARRAY_MAP, MESSAGE_DEACTIVATED_ARRAY_SELECT, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, PROPERTY_LENGTH, SYMBOL_STATE } from "../constants.mjs";
 import { emitValue, equalArrays, getJsonValue, getStringValue } from "../helpers/value.mjs";
-import { getState } from "../helpers/misc.mjs";
+import { deactivateProxy, getReactiveActive, getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { computed } from "./computed.mjs";
-import { getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
+import { getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyDerivations, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlySignal } from "./readonly.mjs";
 import { signal } from "./signal.mjs";
 import { filter } from "@oscarpalmer/atoms/array/filter";
 import { select } from "@oscarpalmer/atoms/array/select";
-//#region src/value/array.ts
+// src/value/array.ts
 function ReactiveArray(value, options) {
 	this[SYMBOL_STATE] = {
-		...getState(void 0, options),
+		...getState(NAME_ARRAY, void 0, options),
 		isArray: true,
 		length: signal(0)
 	};
@@ -21,15 +21,10 @@ function ReactiveArray(value, options) {
 	});
 	setProxyValue.call(this, value);
 }
-ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
-	enumerable: true,
-	get: getArrayLength,
-	set: setArrayLength
-});
 ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
 ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.deactivate = deactivateArray;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
@@ -46,14 +41,33 @@ ReactiveArray.prototype.toString = getStringValue;
 ReactiveArray.prototype.toJSON = getJsonValue;
 ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
+Object.defineProperties(ReactiveArray.prototype, {
+	[PROPERTY_LENGTH]: {
+		enumerable: true,
+		get: getArrayLength,
+		set: setArrayLength
+	},
+	active: {
+		enumerable: true,
+		get: getReactiveActive
+	}
+});
 function array(value, options) {
 	return new ReactiveArray(value, options);
 }
 function clearArrayValues() {
-	this[SYMBOL_STATE].value.length = 0;
+	const state = this[SYMBOL_STATE];
+	if (state.active) state.value.length = 0;
+}
+function deactivateArray() {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	state.length?.deactivate?.();
+	deactivateProxy.call(this);
 }
 function filterArrayValues(callback) {
-	return computed(() => filter(getArrayValues.call(this), callback));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_FILTER);
+	return updateProxyDerivations(this, computed(() => filter(getArrayValues.call(this), callback)));
 }
 function getArrayLength() {
 	return this[SYMBOL_STATE].length.get();
@@ -62,36 +76,47 @@ function getArrayValues(value) {
 	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
 function mapArrayValues(callback) {
-	return computed(() => getArrayValues.call(this).map(callback));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_MAP);
+	return updateProxyDerivations(this, computed(() => getArrayValues.call(this).map((item, index, array) => callback(item, index, array))));
 }
 function peekArrayValue(first, second) {
 	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
 function popArrayValue() {
-	return this[SYMBOL_STATE].value.pop();
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.pop() : void 0;
 }
 function pushArrayValues(...items) {
-	return this[SYMBOL_STATE].value.push(...items);
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.push(...items) : state.value.length;
 }
 function selectArrayValues(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_SELECT);
+	return updateProxyDerivations(this, computed(() => select(getArrayValues.call(this), filter, map)));
 }
 function setArrayLength(value) {
-	const values = this[SYMBOL_STATE].value;
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	const values = state.value;
 	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== values.length) values.length = value;
 }
 function shiftArrayValue() {
-	return this[SYMBOL_STATE].value.shift();
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.shift() : void 0;
 }
 function spliceArrayValues(from, to, ...items) {
-	const values = this[SYMBOL_STATE].value;
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return [];
+	const values = state.value;
 	return values.splice(from, to ?? values.length, ...items);
 }
 function unshiftArrayValues(...items) {
-	return this[SYMBOL_STATE].value.unshift(...items);
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.unshift(...items) : state.value.length;
 }
 function updateArray(instance, type, array) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return () => void 0;
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
@@ -104,5 +129,4 @@ function updateArray(instance, type, array) {
 		return result;
 	};
 }
-//#endregion
 export { array };

package/dist/value/computed.d.mts

@@ -1,6 +1,5 @@
 import { Computed, InternalComputed, ReactiveOptions } from "../models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
-//#region src/value/computed.d.ts
 /**
  * Create a computed value
  *
@@ -9,5 +8,4 @@ import { GenericCallback } from "@oscarpalmer/atoms/models";
  * @returns Computed value
  */
 export declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
-export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): InternalComputed;
-//#endregion
+export declare function internalComputed(callback: GenericCallback, options?: ReactiveOptions<unknown>): InternalComputed;

package/dist/value/computed.mjs

@@ -1,20 +1,24 @@
-import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
+import { ACTIVE, BATCH, MESSAGE_COMPUTED_CALLBACK, NAME_COMPUTED, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SYMBOL_EFFECT, SYMBOL_STATE } from "../constants.mjs";
 import { internalEffect, runEffect } from "../effect.mjs";
 import { getJsonValue, getStringValue, handleSignal, peekSignalValue } from "../helpers/value.mjs";
 import { flushHandlers } from "../batch.mjs";
-import { getState } from "../helpers/misc.mjs";
+import { deactivateComputed, getReactiveActive, getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
-//#region src/value/computed.ts
+// src/value/computed.ts
 function Computed(callback, options) {
-	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_STATE] = getState(NAME_COMPUTED, void 0, options);
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
-Computed.prototype[NAME_MORA] = NAME_COMPUTED;
+Computed.prototype.deactivate = deactivateComputed;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
 Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
+Object.defineProperties(Computed.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 /**
 * Create a computed value
 *
@@ -26,7 +30,7 @@ function computed(callback, options) {
 	return getComputed(callback, options);
 }
 function getComputed(callback, options) {
-	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_COMPUTED_CALLBACK);
 	return new Computed(callback, options);
 }
 function getComputedEffect(instance, callback) {
@@ -49,8 +53,9 @@ function getComputedEffect(instance, callback) {
 	return fx;
 }
 function getComputedValue() {
-	const fx = this[SYMBOL_EFFECT];
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return state.value;
+	const fx = this[SYMBOL_EFFECT];
 	if (ACTIVE.computed != null && fx !== ACTIVE.computed) {
 		state.computeds ??= /* @__PURE__ */ new Set();
 		state.computeds.add(ACTIVE.computed);
@@ -67,10 +72,12 @@ function internalComputed(callback, options) {
 }
 function setAndEmit(instance, value, notify) {
 	const state = instance[SYMBOL_STATE];
-	if (!notify && (state.equal ?? Object.is)(state.value, value)) return;
+	if (!state.active || !notify && (state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
-	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
-	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) if (computed.instance.active) computed.dirty = true;
+	else state.computeds.delete(computed);
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) if (effect.active) BATCH.handlers.set(effect, effect);
+	else state.effects.delete(effect);
 	for (const type of SUBSCRIPTION_TYPES) {
 		if (type === "frozen") continue;
 		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
@@ -81,5 +88,4 @@ function setAndEmit(instance, value, notify) {
 	}
 	flushHandlers();
 }
-//#endregion
 export { computed, internalComputed };

package/dist/value/readonly.d.mts

@@ -1,5 +1,2 @@
-import { InternalSignal, ReadonlyFrozenSignal, ReadonlySignal, SignalState } from "../models.mjs";
-//#region src/value/readonly.d.ts
-export declare function getReadonlyInstance(state: SignalState, frozen: boolean): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown>;
-export declare function getReadonlySignal<Value>(this: InternalSignal, frozen?: never): ReadonlySignal<Value>;
-//#endregion
+import { InternalSignal, ReadonlySignal } from "../models.mjs";
+export declare function getReadonlySignal<Value>(this: InternalSignal, frozen?: never): ReadonlySignal<Value>;

package/dist/value/readonly.mjs

@@ -1,37 +1,45 @@
-import { NAME_MORA, NAME_READONLY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SYMBOL_STATE } from "../constants.mjs";
+import { MESSAGE_DEACTIVATED_READONLY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SYMBOL_READONLY, SYMBOL_STATE } from "../constants.mjs";
 import { getFrozenValue, getJsonValue, getSignalValue, getStringValue, peekSignalValue } from "../helpers/value.mjs";
+import { deactivateReadonly, getReadonlyActive } from "../helpers/misc.mjs";
 import { subscribeToReadonly } from "../helpers/subscription.mjs";
-//#region src/value/readonly.ts
+// src/value/readonly.ts
 function Readonly(state, frozen) {
-	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
 	this[SYMBOL_STATE] = state;
+	this[SYMBOL_READONLY] = {
+		active: true,
+		name: frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL
+	};
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, { value: frozen });
 }
-Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.deactivate = deactivateReadonly;
 Readonly.prototype.get = getReadonlyValue;
 Readonly.prototype.peek = peekReadonlyValue;
 Readonly.prototype.subscribe = subscribeToReadonly;
 Readonly.prototype.toJSON = getJsonValue;
 Readonly.prototype.toString = getStringValue;
-function getReadonlyInstance(state, frozen) {
-	return new Readonly(state, frozen);
-}
+Object.defineProperties(Readonly.prototype, { active: {
+	enumerable: true,
+	get: getReadonlyActive
+} });
 function getReadonlySignal(frozen) {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) throw new Error(MESSAGE_DEACTIVATED_READONLY);
 	const key = frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL;
-	this[SYMBOL_STATE].readonlies ??= {};
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(this[SYMBOL_STATE], frozen === true);
-	return this[SYMBOL_STATE].readonlies[key];
+	state.readonlies ??= {};
+	state.readonlies[key] ??= new Readonly(state, frozen === true);
+	return state.readonlies[key];
 }
 function getReadonlyValue() {
-	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
+	return handleReadonlyValue(this, false, this.frozen);
 }
 function handleReadonlyValue(instance, peek, frozen, copy) {
+	const state = instance[SYMBOL_READONLY];
 	let value;
-	if (peek) value = peekSignalValue.call(instance, copy === true);
-	else value = getSignalValue.call(instance);
+	if (peek) value = peekSignalValue.call(state.active ? instance : [instance, state.value], copy === true);
+	else value = state.active ? getSignalValue.call(instance) : state.value;
 	return frozen ? getFrozenValue(value) : value;
 }
 function peekReadonlyValue(copy) {
-	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+	return handleReadonlyValue(this, true, this.frozen, copy);
 }
-//#endregion
-export { getReadonlyInstance, getReadonlySignal };
+export { getReadonlySignal };

package/dist/value/signal.d.mts

@@ -1,5 +1,4 @@
 import { ReactiveOptions, Signal } from "../models.mjs";
-//#region src/value/signal.d.ts
 /**
  * Create a reactive value from a function result
  *
@@ -23,5 +22,4 @@ export declare function signal<Value>(value: Promise<Value>, options?: ReactiveO
  * @param options Reactivity options
  * @returns Reactive value
  */
-export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
-//#endregion
+export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;

package/dist/value/signal.mjs

@@ -1,15 +1,15 @@
-import { NAME_MORA, NAME_SIGNAL, SYMBOL_STATE } from "../constants.mjs";
+import { NAME_SIGNAL, SYMBOL_STATE } from "../constants.mjs";
 import { emitValue, getJsonValue, getSignalValue, getStringValue, handleSignal, peekSignalValue, updateSignal } from "../helpers/value.mjs";
-import { getState } from "../helpers/misc.mjs";
+import { deactivateReactive, getReactiveActive, getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
 import { getReadonlySignal } from "./readonly.mjs";
-//#region src/value/signal.ts
+// src/value/signal.ts
 function Signal(value, options) {
-	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_STATE] = getState(NAME_SIGNAL, void 0, options);
 	handleSignal(this, value, setAndEmit);
 }
-Signal.prototype[NAME_MORA] = NAME_SIGNAL;
 Signal.prototype.asReadonly = getReadonlySignal;
+Signal.prototype.deactivate = deactivateReactive;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
 Signal.prototype.set = setSignalValue;
@@ -17,6 +17,10 @@ Signal.prototype.subscribe = subscribeToSignal;
 Signal.prototype.toString = getStringValue;
 Signal.prototype.toJSON = getJsonValue;
 Signal.prototype.update = updateSignalValue;
+Object.defineProperties(Signal.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 function setAndEmit(instance, value) {
 	const state = instance[SYMBOL_STATE];
 	if (!(state.equal ?? Object.is)(state.value, value)) {
@@ -33,5 +37,4 @@ function signal(value, options) {
 function updateSignalValue(callback) {
 	updateSignal(this, callback, setAndEmit);
 }
-//#endregion
 export { signal };

package/dist/value/store.d.mts

@@ -1,6 +1,5 @@
 import { ReactiveOptions, ReactiveStore } from "../models.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
-//#region src/value/store.d.ts
 /**
  * Create a reactive store from a function result
  *
@@ -24,5 +23,4 @@ export declare function store<Value extends PlainObject>(value: Promise<Value>,
  * @param options Reactivity options
  * @returns Reactive store
  */
-export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
-//#endregion
+export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;

package/dist/value/store.mjs

@@ -1,20 +1,20 @@
-import { NAME_MORA, NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
+import { NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
 import { getJsonValue, getStringValue } from "../helpers/value.mjs";
-import { getState } from "../helpers/misc.mjs";
+import { deactivateProxy, getReactiveActive, getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { getValueInProxy, notifyProxyValue, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
 import { getReadonlySignal } from "./readonly.mjs";
-//#region src/value/store.ts
+// src/value/store.ts
 function ReactiveStore(value, options) {
 	this[SYMBOL_STATE] = {
-		...getState(void 0, options),
+		...getState(NAME_STORE, void 0, options),
 		isArray: false
 	};
 	this[SYMBOL_STATE].value = new Proxy({}, { set: (target, property, value) => setValueInProxy(this, target, property, value) });
 	setProxyValue.call(this, value);
 }
-ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
+ReactiveStore.prototype.deactivate = deactivateProxy;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
@@ -23,8 +23,11 @@ ReactiveStore.prototype.subscribe = subscribeToProxy;
 ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
+Object.defineProperties(ReactiveStore.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 function store(value, options) {
 	return new ReactiveStore(value, options);
 }
-//#endregion
 export { store };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.38.0",
+	"version": "0.39.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,21 +39,14 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.205"
+		"@oscarpalmer/atoms": "^0.222"
 	},
 	"devDependencies": {
 		"@types/node": "^26.6",
-		"@vitest/coverage-istanbul": "5.0.1",
+		"@vitest/coverage-istanbul": "^5",
 		"jsdom": "^30.1",
 		"tsdown": "^0.23",
 		"typescript": "^7",
-		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-		"vite-plus": "1.0.0",
-		"vitest": "5.0.1"
-	},
-	"overrides": {
-		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-		"vitest": "5.0.1"
-	},
-	"packageManager": "npm@11.19.0"
+		"vite-plus": "^1.4"
+	}
 }

package/src/batch.ts

@@ -1,8 +1,7 @@
-import {attempt} from '@oscarpalmer/atoms/result';
 import {BATCH} from './constants';
 import {runEffect} from './effect';
 import {getFrozenValue, peekSignalValue} from './helpers/value';
-import type {StoredSubscription} from './models';
+import type {EffectState, StoredSubscription} from './models';
 
 // #region Functions
 
@@ -21,7 +20,12 @@ export function flushHandlers(): void {
 			BATCH.handlers.clear();
 
 			for (let index = 0; index < length; index += 1) {
-				const [, handler] = handlers[index];
+				const [owner, handler] = handlers[index];
+
+				if (!owner.active) {
+					continue;
+				}
+
 				const subscription = handler as StoredSubscription;
 
 				if (typeof subscription.frozen === 'boolean') {
@@ -31,7 +35,7 @@ export function flushHandlers(): void {
 							: peekSignalValue.call(subscription.instance, subscription.copy),
 					);
 				} else {
-					runEffect(handler);
+					runEffect(handler as EffectState);
 				}
 			}
 		}

package/src/constants.ts

@@ -17,6 +17,22 @@ export const BATCH: Batch = {
 	handlers: new Map(),
 };
 
+export const MESSAGE_COMPUTED_CALLBACK = 'Computed callback must be a function';
+
+export const MESSAGE_DEACTIVATED_ARRAY_FILTER = 'Cannot filter an inactive reactive array';
+
+export const MESSAGE_DEACTIVATED_ARRAY_MAP = 'Cannot map an inactive reactive array';
+
+export const MESSAGE_DEACTIVATED_ARRAY_SELECT = 'Cannot select from an inactive reactive array';
+
+export const MESSAGE_DEACTIVATED_READONLY = 'Cannot create readonly variant of inactive signal';
+
+export const MESSAGE_DEACTIVATED_SUBSCRIPTION = 'Cannot subscribe to inactive signal';
+
+export const MESSAGE_EFFECT_CALLBACK = 'Effect callback must be a function';
+
+export const MESSAGE_UPDATE_CALLBACK = 'Update callback must be a function';
+
 export const METHODS_AFFECTING_LENGTH: Set<string | symbol> = new Set([
 	'pop',
 	'push',
@@ -39,8 +55,6 @@ export const NAME_COMPUTED = 'computed';
 
 export const NAME_EFFECT = 'effect';
 
-export const NAME_MORA = '$mora';
-
 export const NAME_READONLY = 'readonly';
 
 export const NAME_SIGNAL = 'signal';
@@ -49,32 +63,28 @@ export const NAME_STORE = 'store';
 
 export const NAME_SUBSCRIPTION = 'subscription';
 
-export const NAME_ALL: Set<string> = new Set([
-	NAME_ARRAY,
-	NAME_COMPUTED,
-	NAME_READONLY,
-	NAME_SIGNAL,
-	NAME_STORE,
-]);
+export const NAME_ALL: Set<string> = new Set([NAME_ARRAY, NAME_COMPUTED, NAME_SIGNAL, NAME_STORE]);
 
 export const PROPERTY_LENGTH = 'length';
 
-export const SYMBOL_EFFECT: symbol = Symbol('effect');
+export const SYMBOL_EFFECT: unique symbol = Symbol('effect');
+
+export const SYMBOL_READONLY: unique symbol = Symbol('readonly');
 
-export const SYMBOL_STATE: symbol = Symbol('state');
+export const SYMBOL_STATE: unique symbol = Symbol('state');
 
 export const SUBSCRIPTION_PROPERTY: SubscriptionProperty = {
-	key: NAME_MORA,
+	key: '$mora',
 	value: NAME_SUBSCRIPTION,
 };
 
-export const SUBSCRIPTION_TYPE_COPY: SubscriptionType = 'copy';
+export const SUBSCRIPTION_TYPE_COPY = 'copy' as const;
 
-export const SUBSCRIPTION_TYPE_FROZEN: SubscriptionType = 'frozen';
+export const SUBSCRIPTION_TYPE_FROZEN = 'frozen' as const;
 
-export const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType = 'original';
+export const SUBSCRIPTION_TYPE_ORIGINAL = 'original' as const;
 
-export const SUBSCRIPTION_TYPE_READONLY: SubscriptionType = 'readonly';
+export const SUBSCRIPTION_TYPE_READONLY = 'readonly' as const;
 
 export const SUBSCRIPTION_TYPES_COPY: Set<SubscriptionType> = new Set([
 	SUBSCRIPTION_TYPE_COPY,

package/src/effect.ts

@@ -1,22 +1,40 @@
+import {noop} from '@oscarpalmer/atoms/function';
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {attempt} from '@oscarpalmer/atoms/result';
-import {ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE} from './constants';
-import type {Effect, EffectState} from './models';
+import {ACTIVE, BATCH, MESSAGE_EFFECT_CALLBACK, NAME_EFFECT, SYMBOL_STATE} from './constants';
+import type {Effect, EffectState, InternalEffect} from './models';
 
 // #region Instance
 
-function Effect(this: any, callback: GenericCallback): void {
-	this[SYMBOL_STATE] = {callback};
+function Effect(this: InternalEffect, callback: GenericCallback): void {
+	this[SYMBOL_STATE] = {
+		callback,
+		active: true,
+		name: NAME_EFFECT,
+	};
 
 	runEffect(this[SYMBOL_STATE]);
 }
 
-Effect.prototype[NAME_MORA] = NAME_EFFECT;
+Effect.prototype.stop = stopEffect;
+
+Object.defineProperties(Effect.prototype, {
+	active: {
+		enumerable: true,
+		get: getActive,
+	},
+});
 
 // #endregion
 
 // #region Functions
 
+export function deactivateEffect(state: EffectState): void {
+	state.active = false;
+	state.callback = noop;
+
+	BATCH.handlers.delete(state);
+}
+
 /**
  * Create an effect
  *
@@ -25,12 +43,16 @@ Effect.prototype[NAME_MORA] = NAME_EFFECT;
  */
 export function effect(callback: GenericCallback): Effect {
 	if (typeof callback !== 'function') {
-		throw new TypeError('Effect callback must be a function');
+		throw new TypeError(MESSAGE_EFFECT_CALLBACK);
 	}
 
 	return getEffect(callback)[0];
 }
 
+function getActive(this: InternalEffect): boolean {
+	return this[SYMBOL_STATE].active;
+}
+
 function getEffect(callback: GenericCallback): [Effect, EffectState] {
 	// @ts-expect-error All good, no worries :-)
 	const instance = new Effect(callback);
@@ -54,4 +76,12 @@ export function runEffect(state: EffectState): void {
 	}
 }
 
+function stopEffect(this: InternalEffect): void {
+	const state = this[SYMBOL_STATE];
+
+	if (state.active) {
+		deactivateEffect(state);
+	}
+}
+
 // #endregion