preact-sigma 4.0.0 → 5.0.0

package/dist/index.mjs

@@ -1,539 +1,7 @@
-import { batch, computed, signal, untracked } from "@preact/signals";
-import * as immer from "immer";
+import { a as initializeSigmaInstance, c as sigma, d as listen, f as sigmaStateBrand, i as buildQueryMethod, l as SigmaListenerMap, n as assertDefinitionKeyAvailable, o as setAutoFreeze, r as buildActionMethod, s as shouldSetup, t as Sigma, u as SigmaTarget } from "./runtime-nX4Aygb8.mjs";
+import { action, computed, effect } from "@preact/signals";
+import { immerable } from "immer";
 import { useEffect, useRef, useState } from "preact/hooks";
-//#region src/internal/context.ts
-const disabledContextOptions = {
-	allowAct: false,
-	allowActions: false,
-	allowCommit: false,
-	allowEmit: false,
-	allowQueries: false,
-	allowWrites: false,
-	draftAware: false,
-	draftOnRead: false,
-	liveComputeds: false,
-	reactiveReads: false
-};
-const publicContextOptions = {
-	computedReadonly: {
-		...disabledContextOptions,
-		reactiveReads: true
-	},
-	observe: {
-		...disabledContextOptions,
-		allowQueries: true
-	},
-	queryCommitted: {
-		...disabledContextOptions,
-		allowQueries: true,
-		reactiveReads: true
-	},
-	setup: {
-		...disabledContextOptions,
-		allowAct: true,
-		allowActions: true,
-		allowEmit: true,
-		allowQueries: true
-	}
-};
-const ownerContextOptions = {
-	action: {
-		...disabledContextOptions,
-		allowActions: true,
-		allowCommit: true,
-		allowEmit: true,
-		allowQueries: true,
-		allowWrites: true,
-		draftAware: true,
-		draftOnRead: true,
-		liveComputeds: true
-	},
-	computedDraftAware: {
-		...disabledContextOptions,
-		draftAware: true,
-		liveComputeds: true
-	},
-	queryDraftAware: {
-		...disabledContextOptions,
-		allowQueries: true,
-		draftAware: true,
-		liveComputeds: true
-	}
-};
-const dirtyContexts = {
-	computedReadonly: /* @__PURE__ */ new Set(),
-	observe: /* @__PURE__ */ new Set(),
-	queryCommitted: /* @__PURE__ */ new Set(),
-	setup: /* @__PURE__ */ new Set()
-};
-const contextKinds = Object.keys(dirtyContexts);
-const contextCache = {
-	computedReadonly: /* @__PURE__ */ new WeakMap(),
-	observe: /* @__PURE__ */ new WeakMap(),
-	queryCommitted: /* @__PURE__ */ new WeakMap(),
-	setup: /* @__PURE__ */ new WeakMap()
-};
-const contextOwnerMap = /* @__PURE__ */ new WeakMap();
-let contextCacheFlushScheduled = false;
-function getContext(target, kind) {
-	if (isOwnerContextKind(kind)) return getOwnerContext(target, kind);
-	return getPublicContext(target, kind);
-}
-function getContextOwner(context) {
-	return contextOwnerMap.get(context);
-}
-function registerContextOwner(context, owner) {
-	contextOwnerMap.set(context, owner);
-}
-function createContext(instance, options, owner) {
-	const publicPrototype = Object.getPrototypeOf(instance.publicInstance);
-	return new Proxy(publicPrototype, {
-		get(_target, key, receiver) {
-			if (typeof key !== "string") return Reflect.get(publicPrototype, key, owner?.actionContext ?? instance.publicInstance);
-			if (key === "act") return options.allowAct ? (actionFn) => {
-				if (typeof actionFn !== "function") throw new Error("[preact-sigma] act() requires a function");
-				return runAdHocAction(receiver, actionFn);
-			} : void 0;
-			if (key === "commit") return options.allowCommit && owner ? () => commitActionOwner(owner) : void 0;
-			if (key === "emit") return options.allowEmit && owner ? (name, detail) => {
-				handleActionBoundary(owner, "emit");
-				instance.publicInstance.dispatchEvent(new CustomEvent(name, { detail }));
-			} : void 0;
-			if (instance.stateKeys.has(key)) {
-				if (owner && options.draftAware) return readActionStateValue(owner, key, options);
-				const signal = getSignal(instance, key);
-				return options.reactiveReads ? signal.value : signal.peek();
-			}
-			if (key in instance.type._computeFunctions) {
-				if (owner && options.liveComputeds) return readActionComputedValue(owner, key);
-				const signal = getSignal(instance, key);
-				return options.reactiveReads ? signal.value : signal.peek();
-			}
-			if (options.allowQueries && key in instance.type._queryFunctions) return Reflect.get(instance.publicInstance, key);
-			if (options.allowActions && key in instance.type._actionFunctions) return Reflect.get(instance.publicInstance, key);
-			if (Reflect.has(publicPrototype, key)) return Reflect.get(publicPrototype, key, owner?.actionContext ?? instance.publicInstance);
-		},
-		set(_target, key, value) {
-			if (!owner || !options.allowWrites || typeof key !== "string" || !instance.stateKeys.has(key)) return false;
-			setActionStateValue(owner, key, value);
-			return true;
-		},
-		apply: unsupportedOperation,
-		construct: unsupportedOperation,
-		defineProperty: unsupportedOperation,
-		deleteProperty: unsupportedOperation,
-		getOwnPropertyDescriptor: unsupportedOperation,
-		has: unsupportedOperation,
-		isExtensible: unsupportedOperation,
-		ownKeys: unsupportedOperation,
-		preventExtensions: unsupportedOperation,
-		setPrototypeOf: unsupportedOperation
-	});
-}
-function unsupportedOperation() {
-	throw new Error("[preact-sigma] This operation is not supported by context proxies");
-}
-const kindToOwnerContextKey = {
-	action: "actionContext",
-	computedDraftAware: "computedContext",
-	queryDraftAware: "queryContext"
-};
-function isOwnerContextKind(kind) {
-	return kind in kindToOwnerContextKey;
-}
-function getOwnerContext(owner, kind) {
-	const contextKey = kindToOwnerContextKey[kind];
-	if (owner[contextKey]) return owner[contextKey];
-	const context = createContext(owner.instance, ownerContextOptions[kind], owner);
-	registerSigmaInternals(context, owner.instance);
-	registerContextOwner(context, owner);
-	owner[contextKey] = context;
-	return context;
-}
-function getPublicContext(instance, kind) {
-	const cachedContext = contextCache[kind].get(instance);
-	if (cachedContext) return cachedContext;
-	const context = createContext(instance, publicContextOptions[kind], void 0);
-	registerSigmaInternals(context, instance);
-	contextCache[kind].set(instance, context);
-	dirtyContexts[kind].add(instance);
-	if (!contextCacheFlushScheduled) {
-		contextCacheFlushScheduled = true;
-		setTimeout(() => {
-			for (const queuedKind of contextKinds) {
-				for (const queuedInstance of dirtyContexts[queuedKind]) contextCache[queuedKind].delete(queuedInstance);
-				dirtyContexts[queuedKind].clear();
-			}
-			contextCacheFlushScheduled = false;
-		}, 0);
-	}
-	return context;
-}
-//#endregion
-//#region src/internal/symbols.ts
-const sigmaStateBrand = Symbol("sigma.state");
-const reservedKeys = new Set([
-	"act",
-	"get",
-	"emit",
-	"commit",
-	"on",
-	"setup"
-]);
-//#endregion
-//#region src/internal/runtime.ts
-const sigmaInternalsMap = /* @__PURE__ */ new WeakMap();
-let autoFreezeEnabled = true;
-let nextActionOwnerId = 1;
-let currentDraftOwner;
-function registerSigmaInternals(context, instance) {
-	sigmaInternalsMap.set(context, instance);
-}
-function getSigmaInternals(context) {
-	const instance = sigmaInternalsMap.get(context);
-	if (!instance) throw new Error("[preact-sigma] Invalid sigma context");
-	return instance;
-}
-function isAutoFreeze() {
-	return autoFreezeEnabled;
-}
-/** Controls whether sigma deep-freezes published public state. Auto-freezing starts enabled and the setting is shared across instances. */
-function setAutoFreeze(autoFreeze) {
-	autoFreezeEnabled = autoFreeze;
-	immer.setAutoFreeze(autoFreeze);
-}
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-function getSignal(instance, key) {
-	return instance.publicInstance["#" + key];
-}
-function initializeSigmaInstance(publicInstance, type, initialState) {
-	const stateKeys = new Set(type._defaultStateKeys);
-	if (initialState) for (const key in initialState) stateKeys.add(key);
-	const instance = {
-		currentSetupCleanup: void 0,
-		publicInstance,
-		stateKeys,
-		type,
-		disposed: false
-	};
-	for (const key of stateKeys) {
-		if (reservedKeys.has(key)) throw new Error(`[preact-sigma] Reserved property name: ${key}`);
-		let value = initialState?.[key];
-		if (value === void 0) value = typeof type._defaultState[key] === "function" ? type._defaultState[key].call(void 0) : type._defaultState[key];
-		const container = signal(value);
-		Object.defineProperty(publicInstance, "#" + key, { value: container });
-		Object.defineProperty(publicInstance, key, {
-			get: () => container.value,
-			enumerable: true
-		});
-	}
-	for (const key in type._computeFunctions) Object.defineProperty(publicInstance, "#" + key, { value: computed(() => type._computeFunctions[key].call(getContext(instance, "computedReadonly"))) });
-	registerSigmaInternals(publicInstance, instance);
-}
-function buildQueryMethod(queryFunction) {
-	return function(...args) {
-		const instance = getSigmaInternals(this);
-		const owner = getContextOwner(this);
-		if (owner) return queryFunction.apply(getContext(owner, "queryDraftAware"), args);
-		return computed(() => queryFunction.apply(getContext(instance, "queryCommitted"), args)).value;
-	};
-}
-function buildActionMethod(actionName, actionFn) {
-	return function(...args) {
-		return runActionInvocation(this, actionName, actionFn, args);
-	};
-}
-function runAdHocAction(context, actionFn) {
-	return runActionInvocation(context, "act()", actionFn, []);
-}
-function readActionStateValue(owner, key, options) {
-	if (owner.currentDraft) return owner.currentDraft[key];
-	const signal = getSignal(owner.instance, key);
-	const committedValue = options.reactiveReads ? signal.value : signal.peek();
-	if (options.draftOnRead && immer.isDraftable(committedValue)) return ensureOwnerDraft(owner)[key];
-	return committedValue;
-}
-function readActionComputedValue(owner, key) {
-	return owner.instance.type._computeFunctions[key].call(getContext(owner, "computedDraftAware"));
-}
-function setActionStateValue(owner, key, value) {
-	ensureOwnerDraft(owner)[key] = value;
-}
-function commitActionOwner(owner) {
-	const finalized = finalizeOwnerDraft(owner);
-	if (finalized?.changed) publishState(owner.instance, finalized);
-}
-function handleActionBoundary(owner, boundary, actionName) {
-	const draftOwner = currentDraftOwner;
-	if (!draftOwner?.currentDraft) return;
-	if (!finalizeOwnerDraft(draftOwner)?.changed) return;
-	if (draftOwner === owner) {
-		const message = boundary === "emit" ? `[preact-sigma] Action "${draftOwner.actionName}" has unpublished changes. Call this.commit() before emit().` : `[preact-sigma] Action "${draftOwner.actionName}" has unpublished changes. Call this.commit() before calling another action.`;
-		throw new Error(message);
-	}
-	if (boundary === "emit") throw new Error("[preact-sigma] Unexpected emit boundary. This is a bug.");
-	console.warn(`[preact-sigma] Discarded unpublished action changes from "${draftOwner.actionName}" before running "${actionName ?? "another action"}".`, createDraftMetadata(draftOwner));
-}
-function assertDefinitionKeyAvailable(builder, key, kind) {
-	if (reservedKeys.has(key)) throw new Error(`[preact-sigma] Reserved property name: ${key}`);
-	if (key in builder._computeFunctions || key in builder._queryFunctions || key in builder._actionFunctions) throw new Error(`[preact-sigma] Duplicate key for ${kind}: ${key}`);
-}
-function shouldSetup(publicInstance) {
-	return getSigmaInternals(publicInstance).type._setupFunction !== null;
-}
-function clearCurrentDraft(owner) {
-	owner.currentDraft = void 0;
-	owner.currentBase = void 0;
-	if (currentDraftOwner === owner) currentDraftOwner = void 0;
-}
-function createActionOwner(instance, actionName, actionFn, args) {
-	const owner = {
-		actionFn,
-		actionName,
-		args,
-		id: nextActionOwnerId++,
-		instance,
-		publicInstance: instance.publicInstance
-	};
-	owner.actionContext = getContext(owner, "action");
-	registerSigmaInternals(owner.actionContext, instance);
-	registerContextOwner(owner.actionContext, owner);
-	return owner;
-}
-function runActionInvocation(context, actionName, actionFn, args) {
-	const instance = getSigmaInternals(context);
-	if (instance.disposed) throw new Error("[preact-sigma] Cannot run an action on a disposed sigma state");
-	const isAdHocAction = actionName === "act()";
-	const actionIsAsync = isAsyncFunction(actionFn);
-	if (actionIsAsync && isAdHocAction) throw new Error("[preact-sigma] act() callbacks must stay synchronous");
-	return untracked(() => {
-		let owner;
-		const callerOwner = getContextOwner(context);
-		if (callerOwner && callerOwner.instance === instance && !actionIsAsync) owner = callerOwner;
-		else {
-			handleActionBoundary(callerOwner, "action", actionName);
-			owner = createActionOwner(instance, actionName, actionFn, args);
-		}
-		let result;
-		try {
-			result = actionFn.apply(owner.actionContext, args);
-		} catch (error) {
-			clearCurrentDraft(owner);
-			throw error;
-		}
-		if (isAdHocAction && isPromiseLike(result)) {
-			clearCurrentDraft(owner);
-			Promise.resolve(result).catch(() => {});
-			throw new Error("[preact-sigma] act() callbacks must stay synchronous");
-		}
-		if (!actionIsAsync && isPromiseLike(result)) {
-			clearCurrentDraft(owner);
-			Promise.resolve(result).catch(() => {});
-			throw new Error(`[preact-sigma] Action "${actionName}" must use native async-await syntax to return a promise.`);
-		}
-		if (owner === callerOwner) return result;
-		const finalized = finalizeOwnerDraft(owner);
-		if (finalized?.changed) publishState(instance, finalized);
-		if (isPromiseLike(result)) return resolveAsyncActionResult(owner, result);
-		return result;
-	});
-}
-function createCommitError(owner) {
-	return /* @__PURE__ */ new Error(`[preact-sigma] Async action "${owner.actionName}" finished with unpublished changes. Call this.commit() before await or return.`);
-}
-function createDraftMetadata(owner) {
-	return {
-		action: owner.actionFn,
-		actionArgs: owner.args,
-		actionId: owner.id,
-		actionName: owner.actionName,
-		draftedInstance: currentDraftOwner?.publicInstance ?? owner.publicInstance,
-		instance: owner.instance.publicInstance
-	};
-}
-function disposeCleanupResource(resource) {
-	if (typeof resource === "function") resource();
-	else if (resource instanceof AbortController) resource.abort();
-	else if ("dispose" in resource) resource.dispose();
-	else resource[Symbol.dispose]();
-}
-function assertExactStateKeys(instance, nextState) {
-	const extraKeys = Object.keys(nextState).filter((key) => !instance.stateKeys.has(key));
-	const missingKeys = [...instance.stateKeys].filter((key) => !Object.prototype.hasOwnProperty.call(nextState, key));
-	if (!extraKeys.length && !missingKeys.length) return;
-	let message = "[preact-sigma] replaceState() requires exactly the instance's state keys";
-	if (missingKeys.length) message += `. Missing: ${missingKeys.join(", ")}`;
-	if (extraKeys.length) message += `. Extra: ${extraKeys.join(", ")}`;
-	throw new Error(message);
-}
-function assertNoPendingDraft(operationName) {
-	const owner = currentDraftOwner;
-	if (!owner?.currentDraft) return;
-	throw new Error(`[preact-sigma] ${operationName}() cannot run while action "${owner.actionName}" has unpublished changes. Call this.commit() before ${operationName}().`);
-}
-function snapshotState(instance) {
-	const snapshot = Object.create(null);
-	for (const key of instance.stateKeys) snapshot[key] = getSignal(instance, key).peek();
-	return snapshot;
-}
-function ensureOwnerDraft(owner) {
-	if (owner.currentDraft) return owner.currentDraft;
-	handleActionBoundary(owner, "action", owner.actionName);
-	owner.currentBase = snapshotState(owner.instance);
-	owner.currentDraft = immer.createDraft(owner.currentBase);
-	currentDraftOwner = owner;
-	return owner.currentDraft;
-}
-function finalizeOwnerDraft(owner) {
-	const currentDraft = owner.currentDraft;
-	const oldState = owner.currentBase;
-	if (!currentDraft || !oldState) return;
-	clearCurrentDraft(owner);
-	let patches;
-	let inversePatches;
-	const newState = owner.instance.type._patchesEnabled ? immer.finishDraft(currentDraft, (nextPatches, nextInversePatches) => {
-		patches = nextPatches;
-		inversePatches = nextInversePatches;
-	}) : immer.finishDraft(currentDraft);
-	return {
-		changed: newState !== oldState,
-		inversePatches,
-		newState,
-		oldState,
-		patches
-	};
-}
-function finalizeReplacementState(instance, oldState, nextState) {
-	const draft = immer.createDraft(oldState);
-	for (const key of instance.stateKeys) draft[key] = nextState[key];
-	let patches;
-	let inversePatches;
-	const newState = instance.type._patchesEnabled ? immer.finishDraft(draft, (nextPatches, nextInversePatches) => {
-		patches = nextPatches;
-		inversePatches = nextInversePatches;
-	}) : immer.finishDraft(draft);
-	return {
-		changed: newState !== oldState,
-		inversePatches,
-		newState,
-		oldState,
-		patches
-	};
-}
-function isAsyncFunction(fn) {
-	return fn.constructor.name === "AsyncFunction";
-}
-function isPromiseLike(value) {
-	return value != null && typeof value.then === "function";
-}
-function publishState(instance, finalized) {
-	batch(() => {
-		for (const key of instance.stateKeys) {
-			const nextValue = finalized.newState[key];
-			if (isAutoFreeze()) immer.freeze(nextValue, true);
-			const signal = getSignal(instance, key);
-			signal.value = nextValue;
-		}
-	});
-	instance.type._observeFunction?.call(getContext(instance, "observe"), finalized);
-}
-/**
-* Returns a shallow snapshot of an instance's committed public state.
-*
-* The snapshot includes one own property for each top-level state key and reads
-* the current committed value for that key. Nested sigma states remain as
-* referenced values. Its type is inferred from the instance's sigma-state
-* definition.
-*/
-function snapshot(publicInstance) {
-	return snapshotState(getSigmaInternals(publicInstance));
-}
-/**
-* Replaces an instance's committed public state from a snapshot object.
-*
-* The replacement snapshot must be a plain object with exactly the instance's
-* top-level state keys. It updates committed state outside action semantics and
-* notifies observers when the committed state changes. Its type is inferred
-* from the instance's sigma-state definition.
-*/
-function replaceState(publicInstance, nextState) {
-	const instance = getSigmaInternals(publicInstance);
-	if (!isPlainObject(nextState)) throw new Error("[preact-sigma] replaceState() requires a plain object snapshot");
-	assertNoPendingDraft("replaceState");
-	assertExactStateKeys(instance, nextState);
-	const finalized = finalizeReplacementState(instance, snapshot(publicInstance), nextState);
-	if (finalized.changed) publishState(instance, finalized);
-}
-async function resolveAsyncActionResult(owner, result) {
-	let settledValue;
-	let settledError;
-	let rejected = false;
-	try {
-		settledValue = await result;
-	} catch (error) {
-		rejected = true;
-		settledError = error;
-	}
-	if (currentDraftOwner === owner && owner.currentDraft) {
-		if (finalizeOwnerDraft(owner)?.changed) {
-			const commitError = createCommitError(owner);
-			if (rejected) throw new AggregateError([settledError, commitError], `[preact-sigma] Async action "${owner.actionName}" rejected and left unpublished changes`);
-			throw commitError;
-		}
-	}
-	if (rejected) throw settledError;
-	return settledValue;
-}
-var Sigma = class extends EventTarget {
-	setup(...args) {
-		const instance = getSigmaInternals(this);
-		if (!instance.type._setupFunction) throw new Error("[preact-sigma] Setup is undefined for this sigma state");
-		if (instance.disposed) throw new Error("[preact-sigma] Cannot set up a disposed sigma state");
-		instance.currentSetupCleanup?.();
-		instance.currentSetupCleanup = void 0;
-		const resources = instance.type._setupFunction.apply(getContext(instance, "setup"), args);
-		if (!Array.isArray(resources)) throw new Error("[preact-sigma] Sigma setup handlers must return an array");
-		let cleanup;
-		if (resources.length) {
-			let cleaned = false;
-			cleanup = () => {
-				if (instance.currentSetupCleanup === cleanup) instance.currentSetupCleanup = void 0;
-				if (cleaned) return;
-				cleaned = true;
-				let errors;
-				for (let index = resources.length - 1; index >= 0; index -= 1) try {
-					disposeCleanupResource(resources[index]);
-				} catch (error) {
-					errors ||= [];
-					errors.push(error);
-				}
-				if (errors) throw new AggregateError(errors, "Failed to dispose one or more sigma resources");
-			};
-			instance.currentSetupCleanup = cleanup;
-		} else cleanup = () => {};
-		return cleanup;
-	}
-	get(key) {
-		return getSignal(getSigmaInternals(this), key);
-	}
-	on(name, listener) {
-		const adapter = (event) => {
-			const payload = event.detail;
-			if (payload === void 0) listener();
-			else listener(payload);
-		};
-		this.addEventListener(name, adapter);
-		return () => {
-			this.removeEventListener(name, adapter);
-		};
-	}
-};
-Object.defineProperty(Sigma.prototype, sigmaStateBrand, { value: true });
-//#endregion
 //#region src/framework.ts
 /** Checks whether a value is an instance created by a configured sigma type. */
 function isSigmaState(value) {
@@ -551,7 +19,7 @@ function query(fn) {
 }
 /**
 * Builds sigma-state constructors by accumulating default state, computeds,
-* queries, observers, actions, and setup handlers.
+* queries, actions, and setup handlers.
 *
 * State and event inference starts from `new SigmaType<TState, TEvents>()`.
 * Later builder methods infer names and types from the objects you pass to them.
@@ -564,8 +32,6 @@ var SigmaType = class SigmaType extends Function {
 			static _computeFunctions = Object.create(null);
 			static _defaultState = Object.create(null);
 			static _defaultStateKeys = [];
-			static _observeFunction = null;
-			static _patchesEnabled = false;
 			static _queryFunctions = Object.create(null);
 			static _setupFunction = null;
 			constructor(initialState) {
@@ -625,12 +91,6 @@ var SigmaType = class SigmaType extends Function {
 		}
 		return this;
 	}
-	observe(listener, options) {
-		const type = getTypeInternals(this);
-		type._observeFunction = listener;
-		if (options?.patches) type._patchesEnabled = true;
-		return this;
-	}
 	/**
 	* Adds action methods whose `this` receives draft state, typed events, `commit()`,
 	* and the computeds, queries, and actions already defined on the builder.
@@ -668,44 +128,6 @@ function getTypeInternals(type) {
 	return type;
 }
 //#endregion
-//#region src/listener.ts
-/**
-* A standalone typed event hub with `emit(...)` and `on(...)` methods and full
-* `EventTarget`, `listen(...)`, and `useListener(...)` compatibility.
-*/
-var SigmaTarget = class extends EventTarget {
-	/**
-	* Emits a typed event from the hub.
-	*
-	* Void events dispatch a plain `Event`. Payload events dispatch a
-	* `CustomEvent` whose `detail` holds the payload.
-	*/
-	emit(name, ...[detail]) {
-		this.dispatchEvent(detail === void 0 ? new Event(name) : new CustomEvent(name, { detail }));
-	}
-	/**
-	* Registers a typed event listener and returns an unsubscribe function.
-	*
-	* Payload events pass their payload directly to the listener. Void events
-	* call the listener with no arguments.
-	*/
-	on(name, listener) {
-		const adapter = (event) => listener(event.detail);
-		this.addEventListener(name, adapter);
-		return () => {
-			this.removeEventListener(name, adapter);
-		};
-	}
-};
-/** Adds a listener to a sigma state or DOM target and returns a cleanup function that removes it. */
-function listen(target, name, listener) {
-	const adapter = isSigmaState(target) || target instanceof SigmaTarget ? (event) => listener(event.detail) : listener;
-	target.addEventListener(name, adapter);
-	return () => {
-		target.removeEventListener(name, adapter);
-	};
-}
-//#endregion
 //#region src/hooks.ts
 /**
 * Creates one sigma-state instance for a component.
@@ -737,4 +159,4 @@ function useListener(target, name, listener) {
 	}, [target, name]);
 }
 //#endregion
-export { SigmaTarget, SigmaType, isSigmaState, listen, query, replaceState, setAutoFreeze, snapshot, useListener, useSigma };
+export { SigmaListenerMap, SigmaTarget, SigmaType, action, effect, immerable, isSigmaState, listen, query, setAutoFreeze, sigma, useListener, useSigma };