@oscarpalmer/mora 0.30.0 → 0.32.0

package/dist/value/array.d.mts

@@ -7,7 +7,7 @@ import { ReactiveArray, ReactiveOptions } from "../models.mjs";
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 /**
  * Create a reactive array from a promise
  *
@@ -15,7 +15,7 @@ declare function array<Item>(value: () => Item[] | Promise<Item[]>, options?: Re
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 /**
  * Create a reactive array
  *
@@ -23,6 +23,5 @@ declare function array<Item>(value: Promise<Item[]>, options?: ReactiveOptions<I
  * @param options Reactivity options
  * @returns Reactive array
  */
-declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
-//#endregion
-export { array };
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+//#endregion

package/dist/value/array.mjs

@@ -1,35 +1,33 @@
 import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, NAME_MORA } from "../constants.mjs";
-import { emitValue, equalArrays, getSimpleValue } from "../helpers/value.mjs";
-import { subscribe, unsubscribe } from "../subscription.mjs";
+import { emitValue, equalArrays } from "../helpers/value.mjs";
+import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { reactive } from "./reactive.mjs";
 import { computed } from "./computed.mjs";
-import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
+import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
+import { getReadonlyInstance } from "./readonly.mjs";
 import { signal } from "./signal.mjs";
 import { select } from "@oscarpalmer/atoms/array";
 import { filter } from "@oscarpalmer/atoms/array/filter";
-import { noop } from "@oscarpalmer/atoms/function";
 //#region src/value/array.ts
 function array(value, options) {
 	const [rx, state] = reactive([], options);
-	const indiced = /* @__PURE__ */ new Map();
+	const isArray = true;
 	const length = signal(0);
+	const mapped = /* @__PURE__ */ new Map();
+	const readonlies = {};
 	state.value = new Proxy([], {
 		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, state, length) : Reflect.get(target, property),
-		set: (target, property, value) => setValueInProxy({
-			length,
-			property,
-			state,
-			target,
-			value,
-			isArray: true
-		})
+		set: (target, property, value) => setValueInProxy(isArray, state, target, property, value, length)
 	});
 	function get(value) {
-		return getArrayValue(instance, indiced, state, length, value);
+		return value === "length" ? length.get() : getValueInProxy(isArray, instance, state, mapped, value);
+	}
+	function set(first, second) {
+		setProxyValue(true, state, setArrayValue, setAtIndex, first, second);
 	}
 	const instance = {
 		...rx,
-		length: state.value.length,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
 		at: (index) => get(index),
 		clear: () => {
 			state.value.length = 0;
@@ -37,63 +35,38 @@ function array(value, options) {
 		filter: (callback) => computed(() => filter(get(), callback)),
 		get: (value) => get(value),
 		map: (callback) => computed(() => get().map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
-		peek: (value) => peekArrayValue(state, length, value),
+		notify: () => emitProxyValues(state, mapped),
+		peek: (first, second) => peekArrayValue(state, length, first, second),
 		pop: () => state.value.pop(),
 		push: (...items) => state.value.push(...items),
 		select: (filter, map) => computed(() => select(get(), filter, map)),
-		set: (first, second) => {
-			setProxyValue(true, state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
-		},
+		set: (first, second) => set(first, second),
 		shift: () => state.value.shift(),
 		splice: (from, to, ...items) => state.value.splice(from, to ?? state.value.length, ...items),
-		subscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(instance, indiced, first, true).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
+		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, mapped, first, second, third),
 		unshift: (...items) => state.value.unshift(...items),
-		unsubscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") getReactiveValueInProxy(instance, indiced, first, true)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		},
-		update: (callback) => updateArrayValue(instance, state, callback)
+		update: (callback) => updateProxyValue(true, state, setArrayValue, setAtIndex, callback)
 	};
 	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			value: NAME_ARRAY
-		},
+		[NAME_MORA]: { value: NAME_ARRAY },
 		length: {
 			enumerable: true,
 			get: () => length.get(),
 			set: (value) => setArrayLength(state, value)
 		}
 	});
-	instance.set(value);
+	set(value);
 	return Object.freeze(instance);
 }
-function getArrayValue(instance, indiced, state, length, first) {
-	if (typeof first === "number") return getReactiveValueInProxy(instance, indiced, first, true).get();
-	return first === "length" ? length.get() : getSimpleValue(state);
+function peekArrayValue(state, length, first, second) {
+	return first === "length" ? length.peek() : peekValueInProxy(true, state, first, second);
 }
-function isArrayIndex(value) {
-	return typeof value === "number";
-}
-function isArrayValue(value) {
-	return value == null || Array.isArray(value);
-}
-function peekArrayValue(state, length, value) {
-	if (value === "length") return length.peek();
-	return typeof value === "number" ? state.value.at(value) : state.value.slice();
+function setArrayLength(state, value) {
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
 }
-function setArray(state, value) {
+function setArrayValue(state, value) {
 	state.value.splice(0, state.value.length, ...value ?? []);
 }
-function setArrayLength(state, value) {
-	if (typeof value === "number" && value >= 0 && value !== state.value.length) state.value.length = value;
-}
 function setAtIndex(state, index, value) {
 	const actual = index < 0 ? state.value.length + index : index;
 	if (actual > -1) state.value[actual] = value;
@@ -111,9 +84,5 @@ function updateArray(type, array, state, length) {
 		return result;
 	};
 }
-function updateArrayValue(instance, state, callback) {
-	const updated = callback(state.value);
-	if (updated == null || Array.isArray(updated)) instance.set(updated);
-}
 //#endregion
 export { array };

package/dist/value/computed.d.mts

@@ -7,7 +7,6 @@ import { Computed, ComputedEffect, ReactiveOptions } from "../models.mjs";
  * @param options Reactivity options
  * @returns Computed value
  */
-declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
-declare function internalComputed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): [Computed<Value>, ComputedEffect];
-//#endregion
-export { computed, internalComputed };
+export declare function computed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Computed<Value>;
+export declare function internalComputed<Value>(callback: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): [Computed<Value>, ComputedEffect];
+//#endregion

package/dist/value/computed.mjs

@@ -1,8 +1,8 @@
-import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA } from "../constants.mjs";
+import { ACTIVE, BATCH, NAME_COMPUTED, NAME_MORA, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY } from "../constants.mjs";
 import { internalEffect, runEffect } from "../effect.mjs";
+import { handleSimpleValue, peekSimpleValue } from "../helpers/value.mjs";
 import { flushHandlers } from "../batch.mjs";
-import { handleSimpleValue } from "../helpers/value.mjs";
-import { subscribe } from "../subscription.mjs";
+import { subscribeToSignal } from "../helpers/subscription.mjs";
 import { reactive } from "./reactive.mjs";
 //#region src/value/computed.ts
 /**
@@ -16,21 +16,16 @@ function computed(callback, options) {
 	return getComputed(callback, options)[0];
 }
 function getComputed(callback, options) {
+	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
 	const [rx, state] = reactive(void 0, options);
 	let fx;
 	const instance = {
 		...rx,
 		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
+		peek: (copy) => peekSimpleValue(state.value, copy === true),
+		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_COMPUTED
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_COMPUTED });
 	fx = getComputedEffect(state, callback);
 	return [Object.freeze(instance), fx];
 }
@@ -64,8 +59,13 @@ function setAndEmit(state, value) {
 	if (state.equal(state.value, value)) return;
 	state.value = value;
 	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) subscription.callback(value);
+	for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === "frozen") continue;
+		const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		if (subscriptions != null) for (const [, callback] of subscriptions) callback(peekSimpleValue(state.value, copy));
+	}
 	flushHandlers();
 }
 //#endregion

package/dist/value/reactive.d.mts

@@ -1,5 +1,4 @@
 import { Reactive, ReactiveOptions, ReactiveState } from "../models.mjs";
 //#region src/value/reactive.d.ts
-declare function reactive<Value, Equal = Value>(value: Value, options?: ReactiveOptions<Equal>): [Reactive<Value>, ReactiveState<Value, Equal>];
-//#endregion
-export { reactive };
+export declare function reactive<Value, Item = Value>(value: Value, options?: ReactiveOptions<Item>): [Reactive<Value>, ReactiveState<Value, Item>];
+//#endregion

package/dist/value/reactive.mjs

@@ -4,7 +4,6 @@ function reactive(value, options) {
 		computeds: /* @__PURE__ */ new Set(),
 		effects: /* @__PURE__ */ new Set(),
 		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : Object.is,
-		subscriptions: /* @__PURE__ */ new Map(),
 		value
 	};
 	return [{

package/dist/value/readonly.d.mts

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

package/dist/value/readonly.mjs

@@ -0,0 +1,33 @@
+import { NAME_MORA, NAME_READONLY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_READONLY } from "../constants.mjs";
+import { getFrozenValue, getSimpleValue, peekSimpleValue } from "../helpers/value.mjs";
+import { subscribeToReactive } from "../helpers/subscription.mjs";
+//#region src/value/readonly.ts
+function getReadonlyInstance(state, instances, frozen) {
+	const key = frozen ? "frozen" : "original";
+	instances[key] ??= getReadonlySignal(state, frozen);
+	return instances[key];
+}
+function getReadonlySignal(state, frozen) {
+	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
+	const instance = {
+		get: () => getReadonlyValue(state, false, frozen),
+		peek: (copy) => getReadonlyValue(state, true, frozen, copy),
+		subscribe: (callback) => subscribeToReactive(type, state, callback)
+	};
+	Object.defineProperties(instance, {
+		[NAME_MORA]: { value: NAME_READONLY },
+		frozen: {
+			enumerable: true,
+			value: frozen
+		}
+	});
+	return Object.freeze(instance);
+}
+function getReadonlyValue(state, peek, frozen, copy) {
+	let value;
+	if (peek) value = peekSimpleValue(state.value, copy === true);
+	else value = getSimpleValue(state);
+	return frozen ? getFrozenValue(value) : value;
+}
+//#endregion
+export { getReadonlyInstance, getReadonlySignal };

package/dist/value/signal.d.mts

@@ -7,7 +7,7 @@ import { ReactiveOptions, Signal } from "../models.mjs";
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+export declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value from a promise
  *
@@ -15,7 +15,7 @@ declare function signal<Value>(value: () => Value | Promise<Value>, options?: Re
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
+export declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value
  *
@@ -23,6 +23,5 @@ declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<
  * @param options Reactivity options
  * @returns Reactive value
  */
-declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
-//#endregion
-export { signal };
+export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
+//#endregion

package/dist/value/signal.mjs

@@ -1,7 +1,8 @@
 import { NAME_MORA, NAME_SIGNAL } from "../constants.mjs";
-import { emitValue, getSimpleValue, handleSimpleValue } from "../helpers/value.mjs";
-import { subscribe } from "../subscription.mjs";
+import { emitValue, getSimpleValue, handleSimpleValue, peekSimpleValue, updateSimpleValue } from "../helpers/value.mjs";
+import { subscribeToSignal } from "../helpers/subscription.mjs";
 import { reactive } from "./reactive.mjs";
+import { getReadonlyInstance } from "./readonly.mjs";
 //#region src/value/signal.ts
 function setAndEmit(state, value) {
 	if (!state.equal(state.value, value)) {
@@ -11,25 +12,17 @@ function setAndEmit(state, value) {
 }
 function signal(value, options) {
 	const [rx, state] = reactive(void 0, options);
+	const readonlies = {};
 	const instance = {
 		...rx,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
 		get: () => getSimpleValue(state),
-		peek: () => state.value,
-		set: (value) => {
-			handleSimpleValue(state, value, setAndEmit);
-		},
-		update: (callback) => {
-			handleSimpleValue(state, callback(state.value), setAndEmit);
-		},
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
+		peek: (copy) => peekSimpleValue(state.value, copy === true),
+		set: (value) => handleSimpleValue(state, value, setAndEmit),
+		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true),
+		update: (callback) => updateSimpleValue(state, callback, setAndEmit)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_SIGNAL
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_SIGNAL });
 	handleSimpleValue(state, value, setAndEmit);
 	return Object.freeze(instance);
 }

package/dist/value/store.d.mts

@@ -8,7 +8,7 @@ import { PlainObject } from "@oscarpalmer/atoms/models";
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+export declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store from a promise
  *
@@ -16,7 +16,7 @@ declare function store<Value extends PlainObject>(value: () => Value | Promise<V
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+export declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store
  *
@@ -24,6 +24,5 @@ declare function store<Value extends PlainObject>(value: Promise<Value>, options
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
-//#endregion
-export { store };
+export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
+//#endregion

package/dist/value/store.mjs

@@ -1,15 +1,14 @@
 import { NAME_MORA, NAME_STORE } from "../constants.mjs";
 import { startBatch, stopBatch } from "../batch.mjs";
-import { getSimpleValue } from "../helpers/value.mjs";
-import { noop, subscribe, unsubscribe } from "../subscription.mjs";
+import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { reactive } from "./reactive.mjs";
-import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
-import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
+import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
+import { getReadonlyInstance } from "./readonly.mjs";
 //#region src/value/store.ts
-function isStoreObject(value) {
-	return value == null || isPlainObject(value);
+function setPropertyValue(state, key, value) {
+	state.value[key] = value;
 }
-function setObject(state, value) {
+function setStoreValue(state, value) {
 	startBatch();
 	const actual = value ?? {};
 	const proxy = state.value;
@@ -27,46 +26,23 @@ function setObject(state, value) {
 	}
 	stopBatch();
 }
-function setProperty(state, key, value) {
-	state.value[key] = value;
-}
 function store(value, options) {
 	const [rx, state] = reactive(void 0, options);
+	const isArray = false;
 	const keyed = /* @__PURE__ */ new Map();
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
-		target,
-		property,
-		state,
-		value,
-		isArray: false
-	}) });
+	const readonlies = {};
+	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy(isArray, state, target, property, value) });
 	const instance = {
 		...rx,
-		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
-		notify() {
-			emityProxyValues(state, keyed);
-		},
-		peek: (value) => isKey(value) ? state.value[value] : { ...state.value },
-		set: (first, second) => {
-			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
-		},
-		subscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		},
-		update: (callback) => {
-			const updated = callback(state.value);
-			if (updated == null || isPlainObject(updated)) setObject(state, updated);
-		}
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
+		get: (value) => getValueInProxy(isArray, instance, state, keyed, value),
+		notify: () => emitProxyValues(state, keyed),
+		peek: (first, second) => peekValueInProxy(isArray, state, first, second),
+		set: (first, second) => setProxyValue(isArray, state, setStoreValue, setPropertyValue, first, second),
+		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, keyed, first, second, third),
+		update: (callback) => updateProxyValue(isArray, state, setStoreValue, setPropertyValue, callback)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_STORE
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_STORE });
 	instance.set(value);
 	return Object.freeze(instance);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.30.0",
+	"version": "0.32.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,17 +39,17 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.190"
+		"@oscarpalmer/atoms": "^0.202"
 	},
 	"devDependencies": {
-		"@types/node": "^26.2",
-		"@vitest/coverage-istanbul": "4.1.10",
+		"@types/node": "^26.5",
+		"@vitest/coverage-istanbul": "^4.1",
 		"jsdom": "^30",
-		"tsdown": "^0.22",
+		"tsdown": "^0.23",
 		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
 	},
-	"packageManager": "npm@11.11.1"
+	"packageManager": "npm@11.19.0"
 }

package/src/batch.ts

@@ -1,6 +1,9 @@
 import {BATCH} from './constants';
 import {runEffect} from './effect';
-import type {EffectState, Subscription} from './models';
+import {getFrozenValue, peekSimpleValue} from './helpers/value';
+import type {EffectState, StoredSubscription} from './models';
+
+// #region Functions
 
 export function flushHandlers(): void {
 	if (BATCH.flushing) {
@@ -17,10 +20,15 @@ export function flushHandlers(): void {
 			BATCH.handlers.clear();
 
 			for (let index = 0; index < length; index += 1) {
-				const handler = handlers[index];
-
-				if (typeof (handler as Subscription).destroy === 'function') {
-					(handler as Subscription).callback((handler as Subscription).state.value);
+				const [, handler] = handlers[index];
+				const subscription = handler as StoredSubscription;
+
+				if (typeof subscription.frozen === 'boolean') {
+					subscription.callback(
+						subscription.frozen
+							? getFrozenValue(subscription.state.value)
+							: peekSimpleValue(subscription.state.value, subscription.copy),
+					);
 				} else {
 					runEffect(handler as EffectState);
 				}
@@ -50,3 +58,5 @@ export function stopBatch(): void {
 
 	flushHandlers();
 }
+
+// #endregion

package/src/constants.ts

@@ -1,4 +1,6 @@
-import type {Active, Batch, EffectState, Subscription} from './models';
+import type {Active, Batch, SubscriptionType} from './models';
+
+// #region Variables
 
 export const ACTIVE: Active = {};
 
@@ -11,7 +13,7 @@ export const ARRAY_PEEK = 10;
 export const BATCH: Batch = {
 	depth: 0,
 	flushing: false,
-	handlers: new Set<EffectState | Subscription>(),
+	handlers: new Map(),
 };
 
 export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);
@@ -33,10 +35,46 @@ export const NAME_EFFECT = 'effect';
 
 export const NAME_MORA = '$mora';
 
+export const NAME_READONLY = 'readonly';
+
 export const NAME_SIGNAL = 'signal';
 
 export const NAME_STORE = 'store';
 
-export const NAME_ALL = new Set([NAME_ARRAY, NAME_COMPUTED, NAME_SIGNAL, NAME_STORE]);
+export const NAME_SUBSCRIPTION = 'subscription';
+
+export const NAME_ALL = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_READONLY,
+	NAME_SIGNAL,
+	NAME_STORE,
+]);
 
 export const PROPERTY_LENGTH = 'length';
+
+export const SUBSCRIPTION_PROPERTY = {
+	key: NAME_MORA,
+	value: NAME_SUBSCRIPTION,
+};
+
+export const SUBSCRIPTION_TYPE_COPY: SubscriptionType = 'copy';
+
+export const SUBSCRIPTION_TYPE_FROZEN: SubscriptionType = 'frozen';
+
+export const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType = 'original';
+
+export const SUBSCRIPTION_TYPE_READONLY: SubscriptionType = 'readonly';
+
+export const SUBSCRIPTION_TYPES_COPY = new Set<SubscriptionType>([
+	SUBSCRIPTION_TYPE_COPY,
+	SUBSCRIPTION_TYPE_READONLY,
+]);
+
+export const SUBSCRIPTION_TYPES: Set<SubscriptionType> = new Set([
+	...SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL,
+]);
+
+// #endregion

package/src/effect.ts

@@ -1,7 +1,9 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT} from './constants';
+import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
 import type {Effect, EffectState} from './models';
 
+// #region Functions
+
 /**
  * Create an effect
  *
@@ -22,7 +24,7 @@ function getEffect(callback: GenericCallback): [Effect, EffectState] {
 	};
 
 	const instance = Object.freeze({
-		$mora: NAME_EFFECT,
+		[NAME_MORA]: NAME_EFFECT,
 	});
 
 	runEffect(state);
@@ -45,3 +47,5 @@ export function runEffect(state: EffectState): void {
 		ACTIVE.effect = previousEffect;
 	}
 }
+
+// #endregion