preact-sigma 4.0.0 → 6.0.0

package/dist/index.mjs

@@ -1,727 +1,34 @@
-import { batch, computed, signal, untracked } from "@preact/signals";
-import * as immer 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) {
-	return Boolean(value[sigmaStateBrand]);
-}
-/**
-* Creates a standalone tracked query helper with the same signature as `fn`.
-*
-* Each call is reactive at the call site and does not memoize results across
-* invocations, which makes `query(fn)` a good fit for local tracked helpers
-* that do not need to live on the sigma-state instance.
-*/
-function query(fn) {
-	return ((...args) => computed(() => fn(...args)).value);
-}
+import { a as setAutoFreeze, c as listenersSymbol, i as query, n as SigmaTarget, o as sigma, r as castProtected, t as Sigma } from "./sigma-CJibGQ6g.mjs";
+import { useEffect, useRef } from "preact/hooks";
+//#region src/defaults.ts
 /**
-* Builds sigma-state constructors by accumulating default state, computeds,
-* queries, observers, actions, and setup handlers.
+* Shallowly applies defined initial values over a defaults object.
 *
-* State and event inference starts from `new SigmaType<TState, TEvents>()`.
-* Later builder methods infer names and types from the objects you pass to them.
+* `undefined` initial values leave their matching default value in place.
 */
-var SigmaType = class SigmaType extends Function {
-	constructor(name = "Sigma") {
-		super();
-		const { [name]: type } = { [name]: class extends Sigma {
-			static _actionFunctions = Object.create(null);
-			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) {
-				super();
-				initializeSigmaInstance(this, type, initialState);
-			}
-		} };
-		Object.defineProperties(type, Object.getOwnPropertyDescriptors(SigmaType.prototype));
-		return type;
-	}
-	/**
-	* Adds top-level public state and default values to the builder.
-	*
-	* Each property becomes a reactive public state property on instances. Use a
-	* zero-argument function when each instance needs a fresh object or array.
-	*/
-	defaultState(defaultState) {
-		const type = getTypeInternals(this);
-		for (const key in defaultState) {
-			if (defaultState[key] === void 0) continue;
-			type._defaultState[key] = defaultState[key];
-			type._defaultStateKeys.push(key);
-		}
-		return this;
-	}
-	/**
-	* Adds reactive getter properties for derived values that take no arguments.
-	*
-	* Computed names and return types are inferred from the object you pass.
-	* `this` exposes readonly state plus computeds that are already on the builder.
-	*/
-	computed(computeds) {
-		const type = getTypeInternals(this);
-		for (const key in computeds) {
-			assertDefinitionKeyAvailable(type, key, "computed");
-			type._computeFunctions[key] = computeds[key];
-			Object.defineProperty(this.prototype, key, { get: function() {
-				return this["#" + key].value;
-			} });
-		}
-		return this;
-	}
-	/**
-	* Adds reactive read methods that accept arguments.
-	*
-	* Query names, parameters, and return types are inferred from the object you
-	* pass. Each call tracks reactively at the call site and does not memoize
-	* results across invocations.
-	*/
-	queries(queries) {
-		const type = getTypeInternals(this);
-		for (const key in queries) {
-			assertDefinitionKeyAvailable(type, key, "query");
-			const queryFunction = queries[key];
-			type._queryFunctions[key] = queryFunction;
-			Object.defineProperty(this.prototype, key, { value: buildQueryMethod(queryFunction) });
-		}
-		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.
-	*
-	* Actions create drafts lazily as they need them. Sync actions on the same
-	* instance reuse the current draft, so they can compose and publish once when
-	* the outer action returns. Declared async actions publish their initial
-	* synchronous work on return, then require `this.commit()` to publish later
-	* writes made after `await`. Non-async actions stay synchronous; if one
-	* returns a promise, sigma throws so async boundaries stay explicit.
-	*/
-	actions(actions) {
-		const type = getTypeInternals(this);
-		for (const key in actions) {
-			assertDefinitionKeyAvailable(type, key, "action");
-			const actionFunction = actions[key];
-			type._actionFunctions[key] = actionFunction;
-			Object.defineProperty(this.prototype, key, { value: buildActionMethod(key, actionFunction) });
-		}
-		return this;
-	}
-	/**
-	* Adds an explicit setup handler for side effects and owned resources.
-	*
-	* Every registered handler runs when `instance.setup(...)` is called, and the
-	* setup argument list is inferred from the first handler you add.
-	*/
-	setup(setup) {
-		const type = getTypeInternals(this);
-		type._setupFunction = setup;
-		return this;
-	}
-};
-function getTypeInternals(type) {
-	return type;
+function mergeDefaults(initial, defaults) {
+	if (!initial) return defaults;
+	const merged = { ...defaults };
+	for (const key in initial) if (initial[key] !== void 0) merged[key] = initial[key];
+	return merged;
 }
 //#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);
+function listen(target, name, listener) {
+	if (target instanceof SigmaTarget) {
+		target[listenersSymbol].addListener(name, listener);
 		return () => {
-			this.removeEventListener(name, adapter);
+			target[listenersSymbol].removeListener(name, listener);
 		};
 	}
-};
-/** 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);
+	const eventTarget = target;
+	eventTarget.addEventListener(name, listener);
 	return () => {
-		target.removeEventListener(name, adapter);
+		eventTarget.removeEventListener(name, listener);
 	};
 }
 //#endregion
-//#region src/hooks.ts
-/**
-* Creates one sigma-state instance for a component.
-*
-* `create()` runs once per mounted component instance. When the sigma state
-* defines setup, `useSigma(...)` also runs `setup(...setupArgs)` in an effect
-* and cleans it up when the setup arguments change or the component unmounts.
-*/
-function useSigma(create, setupArgs) {
-	const sigmaState = useState(create)[0];
-	if (shouldSetup(sigmaState)) {
-		const args = setupArgs ?? [];
-		useEffect(() => sigmaState.setup(...args), [sigmaState, ...args]);
-	}
-	return sigmaState;
-}
+//#region src/hooks/useListener.ts
 /**
 * Attaches an event listener in a component and cleans it up automatically.
 *
@@ -737,4 +44,37 @@ function useListener(target, name, listener) {
 	}, [target, name]);
 }
 //#endregion
-export { SigmaTarget, SigmaType, isSigmaState, listen, query, replaceState, setAutoFreeze, snapshot, useListener, useSigma };
+//#region src/hooks/useSigma.ts
+const isArray = Array.isArray;
+const depsCache = /* @__PURE__ */ new WeakMap();
+function depsChanged(container, deps) {
+	const cachedDeps = depsCache.get(container);
+	if (!deps && !cachedDeps) return false;
+	if (!deps || !cachedDeps) return true;
+	if (deps.length !== cachedDeps.length || deps.some((dep, index) => !Object.is(dep, cachedDeps[index]))) return true;
+	return false;
+}
+function useSigma(create, optionsOrDeps) {
+	const container = useRef(null);
+	let setup;
+	let deps;
+	if (isArray(optionsOrDeps)) deps = optionsOrDeps;
+	else {
+		setup = optionsOrDeps?.setup;
+		deps = optionsOrDeps?.deps;
+	}
+	if (!container.current || depsChanged(container, deps)) {
+		depsCache.set(container, deps);
+		container.current = create();
+	}
+	const instance = container.current;
+	useEffect(() => {
+		if ("onSetup" in instance) {
+			const setupArgs = setup ? isArray(setup) ? setup : setup() : [];
+			return instance.setup(...setupArgs);
+		}
+	}, [instance, ...isArray(setup) ? setup : []]);
+	return castProtected(instance);
+}
+//#endregion
+export { Sigma, SigmaTarget, castProtected, listen, mergeDefaults, query, setAutoFreeze, sigma, useListener, useSigma };