coaction 2.1.0 → 3.0.0

package/dist/local.mjs

@@ -0,0 +1,1138 @@
+import { apply, create, isDraft } from "mutative";
+import { computed, computed as computed$1, effect, effectScope, endBatch, endBatch as endBatch$1, isComputed, isEffect, isEffectScope, isSignal, signal, signal as signal$1, startBatch, startBatch as startBatch$1, trigger } from "alien-signals";
+//#region packages/core/src/lifecycle.ts
+const readyStores = /* @__PURE__ */ new WeakSet();
+const readyCallbacks = /* @__PURE__ */ new WeakMap();
+const onStoreReady = (store, callback) => {
+	if (readyStores.has(store)) {
+		callback();
+		return () => void 0;
+	}
+	let callbacks = readyCallbacks.get(store);
+	if (!callbacks) {
+		callbacks = /* @__PURE__ */ new Set();
+		readyCallbacks.set(store, callbacks);
+	}
+	callbacks.add(callback);
+	return () => {
+		callbacks?.delete(callback);
+	};
+};
+const markStoreReady = (store) => {
+	readyStores.add(store);
+	const callbacks = readyCallbacks.get(store);
+	if (!callbacks) return;
+	readyCallbacks.delete(store);
+	callbacks.forEach((callback) => callback());
+	callbacks.clear();
+};
+//#endregion
+//#region packages/core/src/applyMiddlewares.ts
+const isStoreLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.setState === "function" && typeof candidate.getState === "function" && typeof candidate.subscribe === "function" && typeof candidate.destroy === "function" && typeof candidate.apply === "function" && typeof candidate.getPureState === "function";
+};
+const applyMiddlewares = (store, middlewares) => {
+	return middlewares.reduce((store, middleware, index) => {
+		if (process.env.NODE_ENV === "development") {
+			if (typeof middleware !== "function") throw new Error(`middlewares[${index}] should be a function`);
+		}
+		const nextStore = middleware(store);
+		if (process.env.NODE_ENV === "development") {
+			if (!isStoreLike(nextStore)) throw new Error(`middlewares[${index}] should return a store-like object`);
+		}
+		return nextStore;
+	}, store);
+};
+//#endregion
+//#region packages/core/src/utils.ts
+const isEqual = (x, y) => {
+	if (x === y) return x !== 0 || y !== 0 || 1 / x === 1 / y;
+	return x !== x && y !== y;
+};
+const isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+const isUnsafePathSegment = (segment) => typeof segment === "string" && isUnsafeKey(segment);
+var UnsafePatchPathError = class extends Error {
+	name = "UnsafePatchPathError";
+};
+var StateSchemaError = class extends Error {
+	name = "StateSchemaError";
+};
+const hasUnsafePatchPath = (path) => {
+	return (Array.isArray(path) ? path : typeof path === "string" ? path.split("/").filter(Boolean).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")) : []).some(isUnsafePathSegment);
+};
+const formatPatchPath = (path) => Array.isArray(path) ? path.map((segment) => String(segment)).join(".") : String(path);
+const getUnsafePatchPaths = (patches) => patches?.filter((patch) => hasUnsafePatchPath(patch.path)) ?? [];
+const assertSafePatches = (patches, source = "patches") => {
+	const unsafePatches = getUnsafePatchPaths(patches);
+	if (!unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	throw new UnsafePatchPathError(`Unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} cannot be applied from ${source}.`);
+};
+const warnDroppedUnsafePatches = (unsafePatches, source) => {
+	if (process.env.NODE_ENV !== "development" || !unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	console.warn(`Coaction dropped unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} from ${source}.`);
+};
+const sanitizePatches = (patches, options = {}) => {
+	if (options.warnOnDropped) warnDroppedUnsafePatches(getUnsafePatchPaths(patches), options.source ?? "patches");
+	return patches?.filter((patch) => !hasUnsafePatchPath(patch.path)).map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
+		...patch,
+		value: sanitizeReplacementState(patch.value)
+	} : patch);
+};
+const sanitizeCheckedPatches = (patches, source) => {
+	assertSafePatches(patches, source);
+	return sanitizePatches(patches) ?? [];
+};
+const setOwnEnumerable = (target, key, value) => {
+	if (typeof key === "string" && isUnsafeKey(key)) return;
+	target[key] = value;
+};
+const getOwnEnumerableKeys = (source) => {
+	if (typeof source !== "object" || source === null) return [];
+	return Reflect.ownKeys(source).filter((key) => Object.prototype.propertyIsEnumerable.call(source, key));
+};
+const getOwnSchemaKeys = (source) => {
+	if (typeof source !== "object" || source === null) return [];
+	return Reflect.ownKeys(source).filter((key) => !(typeof key === "string" && isUnsafeKey(key)));
+};
+const formatSchemaPath = (path) => path.length ? path.map((key) => String(key)).join(".") : "<root>";
+const assertKnownSchemaKey = (knownKeys, key, path) => {
+	if (typeof key === "string" && isUnsafeKey(key)) return;
+	if (knownKeys.has(key)) return;
+	throw new StateSchemaError(`Unknown state key '${formatSchemaPath([...path, key])}' cannot be added after store initialization. Coaction state schema is fixed.`);
+};
+const assertKnownSliceObject = (key, value) => {
+	if (typeof value === "object" && value !== null) return;
+	throw new StateSchemaError(`State slice '${String(key)}' must remain an object after store initialization. Coaction slice schema is fixed.`);
+};
+const assertKnownSlicePresent = (source, key) => {
+	if (Object.prototype.hasOwnProperty.call(source, key)) return;
+	throw new StateSchemaError(`State slice '${String(key)}' cannot be removed after store initialization. Coaction slice schema is fixed.`);
+};
+const createStateSchema = (rootState, isSliceStore) => {
+	const rootKeys = new Set(getOwnSchemaKeys(rootState));
+	if (!isSliceStore) return { rootKeys };
+	const sliceKeys = /* @__PURE__ */ new Map();
+	if (typeof rootState === "object" && rootState !== null) {
+		const rootRecord = rootState;
+		rootKeys.forEach((key) => {
+			const slice = rootRecord[key];
+			if (typeof slice === "object" && slice !== null) sliceKeys.set(key, new Set(getOwnSchemaKeys(slice)));
+		});
+	}
+	return {
+		rootKeys,
+		sliceKeys
+	};
+};
+const assertKnownStateShape = (source, rootState, schema, isSliceStore, options = {}) => {
+	if (typeof source !== "object" || source === null) return;
+	const rootKeys = schema?.rootKeys ?? new Set(getOwnSchemaKeys(rootState));
+	const sourceRecord = source;
+	const knownSliceEntries = schema?.sliceKeys;
+	if (isSliceStore && options.requireSliceRoots && knownSliceEntries) knownSliceEntries.forEach((_, key) => {
+		assertKnownSlicePresent(sourceRecord, key);
+	});
+	for (const key of getOwnEnumerableKeys(source)) {
+		assertKnownSchemaKey(rootKeys, key, []);
+		if (!isSliceStore) continue;
+		const slice = sourceRecord[key];
+		const knownSliceKeys = schema?.sliceKeys?.get(key) ?? (typeof rootState === "object" && rootState !== null && typeof rootState[key] === "object" && rootState[key] !== null ? new Set(getOwnSchemaKeys(rootState[key])) : void 0);
+		if (!knownSliceKeys) continue;
+		assertKnownSliceObject(key, slice);
+		for (const sliceKey of getOwnEnumerableKeys(slice)) assertKnownSchemaKey(knownSliceKeys, sliceKey, [key]);
+	}
+};
+const isArrayIndexKey = (key) => {
+	if (typeof key !== "string") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+};
+const assignOwnEnumerable = (target, source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (!seen.has(source)) seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) setOwnEnumerable(target, key, sanitizeReplacementState(source[key], seen));
+};
+const cloneOwnEnumerable = (source) => {
+	const target = {};
+	assignOwnEnumerable(target, source);
+	return target;
+};
+const sanitizeReplacementState = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeReplacementState(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			const value = source[key];
+			if (typeof value === "function") continue;
+			setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		const value = source[key];
+		if (typeof value === "function") continue;
+		setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+	}
+	return target;
+};
+const sanitizeInitialStateValue = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeInitialStateValue(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+	}
+	return target;
+};
+const areShallowEqualWithArray = (prev, next) => {
+	if (prev === null || next === null || prev.length !== next.length) return false;
+	const { length } = prev;
+	for (let i = 0; i < length; i += 1) {
+		if (Object.prototype.hasOwnProperty.call(prev, i) !== Object.prototype.hasOwnProperty.call(next, i)) return false;
+		if (!isEqual(prev[i], next[i])) return false;
+	}
+	return true;
+};
+const mergeObject = (target, source, isSlice) => {
+	if (isSlice) {
+		if (typeof source === "object" && source !== null) for (const key of getOwnEnumerableKeys(source)) {
+			if (typeof key === "string" && isUnsafeKey(key)) continue;
+			if (!Object.prototype.hasOwnProperty.call(target, key)) continue;
+			const sourceValue = source[key];
+			if (typeof sourceValue !== "object" || sourceValue === null) continue;
+			const targetValue = target[key];
+			if (typeof targetValue === "object" && targetValue !== null) assignOwnEnumerable(targetValue, sourceValue);
+		}
+	} else if (typeof source === "object" && source !== null) assignOwnEnumerable(target, source);
+};
+const uuid = () => {
+	let timestamp = (/* @__PURE__ */ new Date()).getTime();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+		const randomNum = (timestamp + Math.random() * 16) % 16 | 0;
+		timestamp = Math.floor(timestamp / 16);
+		return (char === "x" ? randomNum : randomNum & 3 | 8).toString(16);
+	});
+};
+//#endregion
+//#region packages/core/src/computed.ts
+const isObjectLike = (value) => typeof value === "object" && value !== null;
+const runComputedRead = (internal, read) => {
+	internal.computedReadDepth = (internal.computedReadDepth ?? 0) + 1;
+	try {
+		return read();
+	} finally {
+		internal.computedReadDepth -= 1;
+	}
+};
+var Computed = class {
+	deps;
+	fn;
+	constructor(deps, fn) {
+		this.deps = deps;
+		this.fn = fn;
+	}
+	createGetter({ internal }) {
+		const memoByReceiver = /* @__PURE__ */ new WeakMap();
+		const lastArgs = /* @__PURE__ */ new WeakMap();
+		const lastResult = /* @__PURE__ */ new WeakMap();
+		const fallbackReceiver = {};
+		const evaluate = (receiver) => {
+			const args = this.deps(internal.module);
+			if (!lastArgs.has(receiver) || !areShallowEqualWithArray(lastArgs.get(receiver), args)) lastResult.set(receiver, this.fn.apply(receiver, args));
+			lastArgs.set(receiver, args);
+			return lastResult.get(receiver);
+		};
+		return function() {
+			const receiver = typeof this === "object" && this !== null ? this : fallbackReceiver;
+			if (internal.isBatching) return evaluate(receiver);
+			let accessor = memoByReceiver.get(receiver);
+			if (!accessor) {
+				accessor = computed$1(() => runComputedRead(internal, () => evaluate(receiver)));
+				memoByReceiver.set(receiver, accessor);
+			}
+			return accessor();
+		};
+	}
+};
+const createCachedGetter = (internal, getter) => {
+	const accessors = /* @__PURE__ */ new WeakMap();
+	const fallbackReceiver = {};
+	return function() {
+		const receiver = typeof this === "object" && this !== null ? this : fallbackReceiver;
+		if (internal.isBatching) return getter.call(receiver);
+		let accessor = accessors.get(receiver);
+		if (!accessor) {
+			accessor = computed$1(() => runComputedRead(internal, () => getter.call(receiver)));
+			accessors.set(receiver, accessor);
+		}
+		return accessor();
+	};
+};
+const createTrackedStateReader = (internal, read, initialValue) => {
+	const slotSignal = signal$1(initialValue);
+	const slotVersionSignal = signal$1(0);
+	let slotVersion = 0;
+	(internal.signalSlots ??= /* @__PURE__ */ new Set()).add({ refresh: () => {
+		const nextValue = read();
+		slotSignal(nextValue);
+		if (internal.mutableInstance && isObjectLike(nextValue)) {
+			slotVersion += 1;
+			slotVersionSignal(slotVersion);
+		}
+	} });
+	return () => {
+		const currentValue = slotSignal();
+		if (internal.mutableInstance && isObjectLike(currentValue)) slotVersionSignal();
+		return read();
+	};
+};
+const refreshSignalSlots = (internal) => {
+	if (!internal.signalSlots?.size) return;
+	startBatch$1();
+	try {
+		internal.signalSlots.forEach((slot) => slot.refresh());
+	} finally {
+		endBatch$1();
+	}
+};
+//#endregion
+//#region packages/core/src/global.ts
+const getGlobal = () => {
+	let _global;
+	if (typeof window !== "undefined") _global = window;
+	else if (typeof global !== "undefined") _global = global;
+	else if (typeof self !== "undefined") _global = self;
+	else _global = {};
+	return _global;
+};
+getGlobal().SharedWorkerGlobalScope || globalThis.WorkerGlobalScope;
+const bindSymbol = Symbol("bind");
+//#endregion
+//#region packages/core/src/getInitialState.ts
+const isObject = (value) => typeof value === "object" && value !== null;
+const isStateFactory = (value) => typeof value === "function";
+const hasGetState = (value) => (typeof value === "object" || typeof value === "function") && value !== null && typeof value.getState === "function";
+const hasBindState = (value) => isObject(value) && !!value[bindSymbol];
+const formatInvalidStateMessage = (type, stateOrFn, key) => `Invalid state ${type} encountered in makeState: ${typeof key !== "undefined" ? `for key ${String(key)}, ` : ""}${typeof stateOrFn}`;
+const getInitialState = (store, createState, internal) => {
+	const makeState = (stateOrFn, key) => {
+		let state;
+		if (isStateFactory(stateOrFn)) state = stateOrFn(store.setState, store.getState, store);
+		else if (isObject(stateOrFn)) state = stateOrFn;
+		else {
+			if (process.env.NODE_ENV !== "production") throw new Error(formatInvalidStateMessage("value", stateOrFn, key));
+			return {};
+		}
+		if (hasGetState(state)) state = state.getState();
+		else if (typeof state === "function") state = state();
+		if (hasBindState(state)) {
+			if (store.isSliceStore) throw new Error("Third-party state binding does not support Slices mode. Please inject a whole store instead.");
+			const binder = state[bindSymbol];
+			const rawState = binder.bind(state);
+			binder.handleStore(store, rawState, state, internal, key);
+			delete state[bindSymbol];
+			return rawState;
+		}
+		if (!isObject(state)) {
+			if (process.env.NODE_ENV !== "production") throw new Error(formatInvalidStateMessage("result", state, key));
+			return {};
+		}
+		return state;
+	};
+	if (!store.isSliceStore) return makeState(createState);
+	return getOwnEnumerableKeys(createState).reduce((stateTree, key) => {
+		if (typeof key === "string" && isUnsafeKey(key)) return stateTree;
+		setOwnEnumerable(stateTree, key, makeState(createState[key], key));
+		return stateTree;
+	}, {});
+};
+//#endregion
+//#region packages/core/src/handleDraft.ts
+const handleDraft = (store, internal) => {
+	internal.rootState = internal.backupState;
+	const [, patches, inversePatches] = internal.finalizeDraft();
+	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	}).patches, "store.patch()");
+	if (safePatches.length) {
+		store.apply(internal.rootState, safePatches);
+		internal.emitPatches?.(safePatches);
+	}
+};
+//#endregion
+//#region packages/core/src/getRawStateLocalAction.ts
+const getActionTarget = (store, sliceKey) => {
+	return typeof sliceKey !== "undefined" ? store.getState()[sliceKey] : store.getState();
+};
+const createLocalAction = ({ fn, internal, key, options, store, sliceKey }) => {
+	return (...args) => {
+		internal.assertAlive?.(`action ${String(key)}`);
+		let actionId;
+		let done;
+		if (store.trace) {
+			actionId = uuid();
+			store.trace({
+				method: String(key),
+				parameters: args,
+				id: actionId,
+				sliceKey
+			});
+			done = (result) => {
+				store.trace({
+					method: String(key),
+					id: actionId,
+					result,
+					sliceKey
+				});
+			};
+		}
+		const traceAction = (run) => {
+			try {
+				const result = run();
+				if (result instanceof Promise) return result.then((value) => {
+					done?.(value);
+					return value;
+				}, (error) => {
+					done?.(error);
+					throw error;
+				});
+				done?.(result);
+				return result;
+			} catch (error) {
+				done?.(error);
+				throw error;
+			}
+		};
+		const enablePatches = store.transport ?? options.enablePatches;
+		return traceAction(() => {
+			if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+				let result;
+				const handleResult = (isDrafted) => {
+					handleDraft(store, internal);
+					if (isDrafted) {
+						internal.backupState = internal.rootState;
+						const [draft, finalize] = create(internal.rootState, { enablePatches: true });
+						internal.finalizeDraft = finalize;
+						internal.rootState = draft;
+					}
+				};
+				const isDrafted = isDraft(internal.rootState);
+				if (isDrafted) handleResult();
+				internal.backupState = internal.rootState;
+				const [draft, finalize] = create(internal.rootState, { enablePatches: true });
+				internal.finalizeDraft = finalize;
+				internal.rootState = draft;
+				let asyncResult;
+				try {
+					result = fn.apply(getActionTarget(store, sliceKey), args);
+					if (result instanceof Promise) asyncResult = result;
+				} finally {
+					if (!asyncResult) handleResult(isDrafted);
+				}
+				if (asyncResult) return asyncResult.then((value) => {
+					handleResult(isDrafted);
+					return value;
+				}, (error) => {
+					handleResult(isDrafted);
+					throw error;
+				});
+				return result;
+			}
+			if (internal.mutableInstance && internal.actMutable) return internal.actMutable(() => {
+				return fn.apply(getActionTarget(store, sliceKey), args);
+			});
+			return fn.apply(getActionTarget(store, sliceKey), args);
+		});
+	};
+};
+//#endregion
+//#region packages/core/src/immutableState.ts
+const isImmutableStateObject = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value)) return true;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const getImmutableStateSnapshot = (value, cache) => {
+	if (!isImmutableStateObject(value)) return value;
+	const cached = cache.get(value);
+	if (cached) return cached;
+	const isArray = Array.isArray(value);
+	const snapshot = isArray ? new Array(value.length) : Object.create(Object.getPrototypeOf(value));
+	cache.set(value, snapshot);
+	for (const key of Reflect.ownKeys(value)) {
+		if (isArray && key === "length") continue;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (Object.prototype.hasOwnProperty.call(descriptor, "value")) descriptor.value = getImmutableStateSnapshot(descriptor.value, cache);
+		Object.defineProperty(snapshot, key, descriptor);
+	}
+	return Object.freeze(snapshot);
+};
+const createImmutableSnapshotPatches = (patches, cache) => patches.map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
+	...patch,
+	value: getImmutableStateSnapshot(patch.value, cache)
+} : patch);
+const finalizeImmutableStateSnapshot = (state, snapshot, patches, cache, sources) => {
+	const mapPair = (value, snapshotValue) => {
+		if (isImmutableStateObject(value) && isImmutableStateObject(snapshotValue)) {
+			cache.set(value, snapshotValue);
+			sources?.set(snapshotValue, value);
+		}
+	};
+	mapPair(state, snapshot);
+	for (const patch of patches) {
+		let value = state;
+		let snapshotValue = snapshot;
+		const ancestors = [];
+		if (isImmutableStateObject(snapshotValue)) ancestors.push(snapshotValue);
+		for (const key of patch.path) {
+			if (!isImmutableStateObject(value) || !isImmutableStateObject(snapshotValue)) break;
+			value = value[key];
+			snapshotValue = snapshotValue[key];
+			mapPair(value, snapshotValue);
+			if (isImmutableStateObject(snapshotValue)) ancestors.push(snapshotValue);
+		}
+		for (let index = ancestors.length - 1; index >= 0; index -= 1) if (!Object.isFrozen(ancestors[index])) Object.freeze(ancestors[index]);
+	}
+};
+const indexImmutableStateSnapshot = (state, snapshot, sources, seen = /* @__PURE__ */ new WeakSet()) => {
+	if (!isImmutableStateObject(state) || !isImmutableStateObject(snapshot) || seen.has(snapshot)) return;
+	seen.add(snapshot);
+	sources.set(snapshot, state);
+	for (const key of Reflect.ownKeys(state)) {
+		const stateDescriptor = Object.getOwnPropertyDescriptor(state, key);
+		const snapshotDescriptor = Object.getOwnPropertyDescriptor(snapshot, key);
+		if (stateDescriptor && snapshotDescriptor && Object.prototype.hasOwnProperty.call(stateDescriptor, "value") && Object.prototype.hasOwnProperty.call(snapshotDescriptor, "value")) indexImmutableStateSnapshot(stateDescriptor.value, snapshotDescriptor.value, sources, seen);
+	}
+};
+//#endregion
+//#region packages/core/src/getRawStateStateProperty.ts
+const assertImmutableStateMutationAllowed = (internal) => {
+	if (internal.mutableInstance || internal.isBatching) return;
+	throw new Error("Direct state mutation is not allowed in immutable Coaction stores. Wrap mutations in set(() => { ... }).");
+};
+const readonlyProxyCache = /* @__PURE__ */ new WeakMap();
+const getReadonlyProxyCache = (internal) => {
+	let cache = readonlyProxyCache.get(internal);
+	if (!cache) {
+		cache = /* @__PURE__ */ new WeakMap();
+		readonlyProxyCache.set(internal, cache);
+	}
+	return cache;
+};
+const getPublicStateObject = (internal, value, sliceKey) => {
+	if (value === internal.rootState) return internal.module;
+	if (typeof sliceKey === "undefined" || typeof internal.rootState !== "object" || internal.rootState === null || typeof internal.module !== "object" || internal.module === null) return;
+	const rootState = internal.rootState;
+	const module = internal.module;
+	if (rootState[sliceKey] === value) return module[sliceKey];
+};
+const toReadonlyStateValue = (internal, value, sliceKey) => {
+	if (internal.mutableInstance || internal.isBatching || !isImmutableStateObject(value)) return value;
+	if (internal.computedReadDepth) {
+		const cache = internal.computedSnapshotCache ??= /* @__PURE__ */ new WeakMap();
+		if (isImmutableStateObject(internal.rootState) && !cache.has(internal.rootState)) getImmutableStateSnapshot(internal.rootState, cache);
+		return getImmutableStateSnapshot(value, cache);
+	}
+	const publicValue = getPublicStateObject(internal, value, sliceKey);
+	if (publicValue) return publicValue;
+	const cache = getReadonlyProxyCache(internal);
+	const cached = cache.get(value);
+	if (cached) return cached;
+	const proxy = new Proxy(value, {
+		get(target, key, receiver) {
+			return toReadonlyStateValue(internal, Reflect.get(target, key, receiver), sliceKey);
+		},
+		set() {
+			assertImmutableStateMutationAllowed(internal);
+			return false;
+		},
+		deleteProperty() {
+			assertImmutableStateMutationAllowed(internal);
+			return false;
+		},
+		defineProperty() {
+			assertImmutableStateMutationAllowed(internal);
+			return false;
+		},
+		setPrototypeOf() {
+			assertImmutableStateMutationAllowed(internal);
+			return false;
+		}
+	});
+	cache.set(value, proxy);
+	return proxy;
+};
+const toPublicComputedValue = (internal, value, sliceKey) => {
+	if (!isImmutableStateObject(value)) return value;
+	const rootSnapshot = internal.computedSnapshotCache?.get(internal.rootState);
+	const sources = internal.computedSnapshotSources ??= /* @__PURE__ */ new WeakMap();
+	let source = sources.get(value);
+	if (!source && Object.isFrozen(value) && rootSnapshot) {
+		indexImmutableStateSnapshot(internal.rootState, rootSnapshot, sources);
+		source = sources.get(value);
+	}
+	if (source) internal.computedIdentityRequired = true;
+	return source ? toReadonlyStateValue(internal, source, sliceKey) : value;
+};
+const prepareStateDescriptor = ({ descriptor, initialStateSeen, internal, key, rawState, sliceKey }) => {
+	const isComputed = descriptor.value instanceof Computed;
+	const readStateValue = () => typeof sliceKey !== "undefined" ? internal.rootState[sliceKey][key] : internal.rootState[key];
+	const initialValue = isComputed ? descriptor.value : sanitizeInitialStateValue(descriptor.value, initialStateSeen);
+	if (internal.mutableInstance) Object.defineProperty(rawState, key, {
+		get: () => internal.mutableInstance[key],
+		set: (value) => {
+			internal.mutableInstance[key] = value;
+		},
+		configurable: true,
+		enumerable: descriptor.enumerable
+	});
+	else if (!isComputed) Object.defineProperty(rawState, key, {
+		value: initialValue,
+		configurable: true,
+		enumerable: descriptor.enumerable,
+		writable: true
+	});
+	if (isComputed) {
+		if (internal.mutableInstance) throw new Error("Computed is not supported with mutable instance");
+		const getComputed = descriptor.value.createGetter({ internal });
+		descriptor.get = function() {
+			return toPublicComputedValue(internal, getComputed.call(this), sliceKey);
+		};
+	} else if (typeof sliceKey !== "undefined") {
+		const read = createTrackedStateReader(internal, readStateValue, initialValue);
+		descriptor.get = () => toReadonlyStateValue(internal, read(), sliceKey);
+		descriptor.set = (value) => {
+			assertImmutableStateMutationAllowed(internal);
+			internal.rootState[sliceKey][key] = value;
+		};
+	} else {
+		const read = createTrackedStateReader(internal, readStateValue, initialValue);
+		descriptor.get = () => toReadonlyStateValue(internal, read());
+		descriptor.set = (value) => {
+			assertImmutableStateMutationAllowed(internal);
+			internal.rootState[key] = value;
+		};
+	}
+	delete descriptor.value;
+	delete descriptor.writable;
+};
+const prepareAccessorDescriptor = ({ descriptor, internal, sliceKey }) => {
+	if (internal.mutableInstance || typeof descriptor.get !== "function") return;
+	const getComputed = createCachedGetter(internal, descriptor.get);
+	descriptor.get = function() {
+		return toPublicComputedValue(internal, getComputed.call(this), sliceKey);
+	};
+};
+//#endregion
+//#region packages/core/src/getRawState.ts
+const defaultClientExecuteSyncTimeoutMs = 1500;
+const lockPublicStateObject = (state) => {
+	Object.freeze(state);
+	return state;
+};
+const getClientExecuteSyncTimeoutMs = (options) => {
+	const timeout = options.executeSyncTimeoutMs;
+	if (typeof timeout === "undefined") return defaultClientExecuteSyncTimeoutMs;
+	if (!Number.isFinite(timeout) || timeout < 0) throw new Error("executeSyncTimeoutMs must be a finite number greater than or equal to 0");
+	return timeout;
+};
+const getRawState = (store, internal, initialState, options, createClientAction) => {
+	const clientExecuteSyncTimeoutMs = getClientExecuteSyncTimeoutMs(options);
+	const rawState = {};
+	const handle = (_rawState, _initialState, sliceKey) => {
+		internal.mutableInstance = internal.toMutableRaw?.(_initialState);
+		const initialStateSeen = /* @__PURE__ */ new WeakMap();
+		initialStateSeen.set(_initialState, _rawState);
+		const safeDescriptors = {};
+		const descriptors = Object.getOwnPropertyDescriptors(_initialState);
+		Reflect.ownKeys(descriptors).forEach((key) => {
+			if (typeof key === "string" && isUnsafeKey(key)) return;
+			safeDescriptors[key] = Reflect.get(descriptors, key);
+		});
+		Reflect.ownKeys(safeDescriptors).forEach((key) => {
+			const descriptor = safeDescriptors[key];
+			if (typeof descriptor === "undefined") return;
+			if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+				prepareAccessorDescriptor({
+					descriptor,
+					internal,
+					sliceKey
+				});
+				return;
+			}
+			if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+				if (typeof descriptor.value !== "function") {
+					prepareStateDescriptor({
+						descriptor,
+						initialStateSeen,
+						internal,
+						key,
+						rawState: _rawState,
+						sliceKey
+					});
+					return;
+				}
+				if (store.share === "client") {
+					if (typeof key !== "string") return;
+					if (!createClientAction) throw new Error("Client action runtime is not configured");
+					descriptor.value = createClientAction({
+						clientExecuteSyncTimeoutMs,
+						internal,
+						key,
+						store,
+						sliceKey
+					});
+				} else descriptor.value = createLocalAction({
+					fn: descriptor.value,
+					internal,
+					key,
+					options,
+					store,
+					sliceKey
+				});
+			}
+		});
+		return lockPublicStateObject(Object.defineProperties({}, safeDescriptors));
+	};
+	if (store.isSliceStore) {
+		internal.module = {};
+		getOwnEnumerableKeys(initialState).forEach((key) => {
+			if (typeof key === "string" && isUnsafeKey(key)) return;
+			const sliceRawState = {};
+			setOwnEnumerable(rawState, key, sliceRawState);
+			setOwnEnumerable(internal.module, key, handle(sliceRawState, initialState[key], key));
+		});
+		lockPublicStateObject(internal.module);
+	} else internal.module = handle(rawState, initialState);
+	return rawState;
+};
+//#endregion
+//#region packages/core/src/handleState.ts
+const handleState = (store, internal, options) => {
+	let defaultResultValidated = false;
+	const defaultUpdater = (next) => {
+		defaultResultValidated = false;
+		const merge = (_next = next) => {
+			if (_next !== next) internal.validateState?.(_next);
+			assertKnownStateShape(_next, internal.rootState, internal.stateSchema, store.isSliceStore);
+			mergeObject(internal.rootState, _next, store.isSliceStore);
+		};
+		const fn = typeof next === "function" ? () => {
+			const returnValue = next(internal.module);
+			if (returnValue instanceof Promise) {
+				returnValue.catch(() => void 0);
+				throw new Error("setState with async function is not supported");
+			}
+			if (typeof returnValue === "object" && returnValue !== null) merge(returnValue);
+		} : merge;
+		if (!(store.transport ?? options.enablePatches) && internal.mutableInstance) {
+			if (internal.actMutable) {
+				internal.actMutable(() => {
+					fn.apply(null);
+				});
+				defaultResultValidated = true;
+				return [];
+			}
+			fn.apply(null);
+			defaultResultValidated = true;
+			return [];
+		}
+		internal.backupState = internal.rootState;
+		let patches;
+		let inversePatches;
+		try {
+			const result = create(internal.rootState, (draft) => {
+				internal.rootState = draft;
+				return fn.apply(null);
+			}, { enablePatches: true });
+			assertKnownStateShape(result[0], internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+			internal.validateState?.(internal.getTransportState?.() ?? result[0]);
+			patches = result[1];
+			inversePatches = result[2];
+		} finally {
+			internal.rootState = internal.backupState;
+		}
+		const patch = store.patch;
+		const finalPatches = patch ? patch({
+			patches,
+			inversePatches
+		}) : {
+			patches,
+			inversePatches
+		};
+		if (!patch) internal.validatePatches?.(finalPatches.patches);
+		const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+		const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
+		if (safePatches.length) {
+			defaultResultValidated = internal.applyValidatedPatches?.(internal.rootState, safePatches, !patch) ?? false;
+			if (!internal.applyValidatedPatches) store.apply(internal.rootState, safePatches);
+		} else defaultResultValidated = true;
+		return [
+			internal.rootState,
+			safePatches,
+			safeInversePatches
+		];
+	};
+	const setState = (next, updater = defaultUpdater) => {
+		internal.assertAlive?.("setState");
+		internal.assertMutationAllowed?.("setState");
+		if (store.share === "client") throw new Error(`setState() cannot be called in the client store. To update the state, please trigger a store method with setState() instead.`);
+		if (internal.isBatching) throw new Error("setState cannot be called within the updater");
+		if (next === null) return [];
+		if (typeof next === "object") {
+			internal.validateState?.(next);
+			assertKnownStateShape(next, internal.rootState, internal.stateSchema, store.isSliceStore);
+		}
+		internal.isBatching = true;
+		if (!store.share && !options.enablePatches && !internal.mutableInstance && updater === defaultUpdater) try {
+			if (typeof next === "function") try {
+				internal.backupState = internal.rootState;
+				const snapshotCache = internal.computedSnapshotCache;
+				const snapshotSources = internal.computedIdentityRequired ? internal.computedSnapshotSources : void 0;
+				const snapshot = snapshotCache?.get(internal.rootState);
+				const updateSnapshot = Boolean(snapshot && snapshotCache);
+				const produced = create(internal.rootState, (draft) => {
+					internal.rootState = draft;
+					const returnValue = next(internal.module);
+					if (returnValue instanceof Promise) {
+						returnValue.catch(() => void 0);
+						throw new Error("setState with async function is not supported");
+					}
+					if (typeof returnValue === "object" && returnValue !== null) {
+						assertKnownStateShape(returnValue, internal.rootState, internal.stateSchema, store.isSliceStore);
+						mergeObject(internal.rootState, returnValue, store.isSliceStore);
+					}
+				}, { enablePatches: updateSnapshot });
+				const nextState = updateSnapshot ? produced[0] : produced;
+				assertKnownStateShape(nextState, internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				if (updateSnapshot) {
+					const patches = produced[1];
+					finalizeImmutableStateSnapshot(nextState, apply(snapshot, createImmutableSnapshotPatches(patches, snapshotCache)), patches, snapshotCache, snapshotSources);
+				}
+				internal.rootState = nextState;
+			} catch (error) {
+				internal.rootState = internal.backupState;
+				throw error;
+			}
+			else {
+				const copy = cloneOwnEnumerable(internal.rootState);
+				if (store.isSliceStore) {
+					const nextRecord = next;
+					const copyRecord = copy;
+					for (const key of getOwnEnumerableKeys(nextRecord)) {
+						if (!Object.prototype.hasOwnProperty.call(copyRecord, key)) continue;
+						const sourceValue = nextRecord[key];
+						if (typeof sourceValue !== "object" || sourceValue === null) continue;
+						const targetValue = copyRecord[key];
+						if (typeof targetValue !== "object" || targetValue === null) continue;
+						const sliceCopy = cloneOwnEnumerable(targetValue);
+						mergeObject(sliceCopy, sourceValue);
+						setOwnEnumerable(copyRecord, key, sliceCopy);
+					}
+				} else mergeObject(copy, next);
+				assertKnownStateShape(copy, internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				internal.rootState = copy;
+			}
+			refreshSignalSlots(internal);
+			if (internal.updateImmutable) internal.updateImmutable(internal.rootState);
+			else internal.listeners.forEach((listener) => listener());
+			return [];
+		} finally {
+			internal.isBatching = false;
+		}
+		let result;
+		try {
+			const isDrafted = internal.mutableInstance && isDraft(internal.rootState);
+			if (isDrafted) handleDraft(store, internal);
+			result = updater(next);
+			if (internal.mutableInstance) assertKnownStateShape(internal.rootState, internal.backupState ?? internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+			if (!(updater === defaultUpdater && defaultResultValidated)) internal.validateState?.(internal.getTransportState?.() ?? internal.rootState);
+			if (isDrafted) {
+				internal.backupState = internal.rootState;
+				const [draft, finalize] = create(internal.rootState, { enablePatches: true });
+				internal.finalizeDraft = finalize;
+				internal.rootState = draft;
+			}
+		} finally {
+			internal.isBatching = false;
+		}
+		const trustedDefaultResult = updater === defaultUpdater && defaultResultValidated;
+		if (result?.length && !trustedDefaultResult) {
+			internal.validatePatches?.(result[1]);
+			result = [
+				result[0],
+				sanitizeCheckedPatches(result[1], "setState updater result"),
+				sanitizeCheckedPatches(result[2], "setState updater inverse result")
+			];
+		}
+		if (result?.[1]) internal.emitPatches?.(result[1]);
+		return result;
+	};
+	const getState = (deps, selector) => deps && selector ? new Computed(deps, selector) : internal.module;
+	return {
+		setState,
+		getState
+	};
+};
+//#endregion
+//#region packages/core/src/storeFactory.ts
+const namespaceMap = /* @__PURE__ */ new Map();
+let hasWarnedAmbiguousFunctionMap = false;
+const warnAmbiguousFunctionMap = () => {
+	if (hasWarnedAmbiguousFunctionMap || process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test") return;
+	hasWarnedAmbiguousFunctionMap = true;
+	console.warn([
+		`sliceMode: 'auto' inferred slices from an object of functions.`,
+		`This shape is ambiguous with a single store that only contains methods.`,
+		`Use create({ ping() {} }, { sliceMode: 'single' }) for a plain method store,`,
+		`or create({ counter: (set) => ({ count: 0 }) }, { sliceMode: 'slices' }) for slices.`
+	].join(" "));
+};
+const createStore = (createState, options, runtime = {}) => {
+	const { share, validatePatches, validateReplacementSource, validateState } = runtime;
+	const store = {};
+	const internal = {
+		sequence: 0,
+		isBatching: false,
+		listeners: /* @__PURE__ */ new Set(),
+		destroyCallbacks: /* @__PURE__ */ new Set(),
+		validatePatches,
+		validateReplacementSource,
+		validateState
+	};
+	internal.notifyStateChange = () => {
+		refreshSignalSlots(internal);
+		internal.listeners.forEach((listener) => listener());
+	};
+	const name = options.name ?? "default";
+	const shouldTrackName = share === "main" && process.env.NODE_ENV !== "test";
+	const releaseStoreName = () => {
+		if (shouldTrackName) namespaceMap.delete(name);
+	};
+	if (shouldTrackName) {
+		if (namespaceMap.get(name)) throw new Error(`Store name '${name}' is not unique.`);
+		namespaceMap.set(name, true);
+	}
+	try {
+		const { setState, getState } = handleState(store, internal, options);
+		const subscribe = (listener) => {
+			internal.assertAlive?.("subscribe");
+			internal.listeners.add(listener);
+			return () => internal.listeners.delete(listener);
+		};
+		let isDestroyed = false;
+		internal.assertAlive = (operation) => {
+			if (isDestroyed) throw new Error(`${operation} cannot be called after store.destroy().`);
+		};
+		const destroy = () => {
+			if (isDestroyed) return;
+			isDestroyed = true;
+			let firstError;
+			const callbacks = [...internal.destroyCallbacks ?? []];
+			internal.destroyCallbacks?.clear();
+			for (const callback of callbacks) try {
+				callback();
+			} catch (error) {
+				firstError ??= error;
+			}
+			internal.listeners.clear();
+			try {
+				store.transport?.dispose();
+			} catch (error) {
+				firstError ??= error;
+			} finally {
+				releaseStoreName();
+			}
+			if (firstError) throw firstError;
+		};
+		const applyState = (state, patches, prepared = false, skipFinalValidation = false) => {
+			internal.assertAlive?.("apply");
+			internal.assertMutationAllowed?.("apply");
+			if (patches && !prepared) validatePatches?.(patches);
+			if (!prepared) assertSafePatches(patches, "store.apply()");
+			const safePatches = prepared ? patches : sanitizePatches(patches);
+			const baseState = state === internal.module ? internal.rootState : state;
+			if (baseState !== internal.rootState) validateReplacementSource?.(baseState);
+			const appliedState = safePatches ? apply(baseState, safePatches) : baseState;
+			const nextState = prepared ? appliedState : sanitizeReplacementState(appliedState);
+			if (!skipFinalValidation) {
+				assertKnownStateShape(nextState, internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				validateState?.(internal.getTransportState?.() ?? nextState);
+			}
+			internal.rootState = nextState;
+			refreshSignalSlots(internal);
+			if (internal.updateImmutable) internal.updateImmutable(internal.rootState);
+			else internal.listeners.forEach((listener) => listener());
+		};
+		const apply$1 = (state = internal.rootState, patches) => applyState(state, patches);
+		internal.applyValidatedPatches = (state, patches, skipFinalValidation) => {
+			if (store.apply !== apply$1) {
+				store.apply(state, patches);
+				return false;
+			}
+			applyState(state, patches, true, skipFinalValidation);
+			return true;
+		};
+		const getPureState = () => internal.rootState;
+		const isFunctionMapObject = () => {
+			if (typeof createState !== "object" || createState === null) return false;
+			const values = getOwnEnumerableKeys(createState).map((key) => createState[key]);
+			return values.length > 0 && values.every((value) => typeof value === "function");
+		};
+		const getIsSliceStore = () => {
+			const sliceMode = options.sliceMode ?? "auto";
+			if (sliceMode === "single") return false;
+			if (sliceMode === "slices") {
+				if (!isFunctionMapObject()) throw new Error(`sliceMode: 'slices' requires createState to be an object of slice functions.`);
+				return true;
+			}
+			if (isFunctionMapObject()) {
+				warnAmbiguousFunctionMap();
+				return true;
+			}
+			return false;
+		};
+		const isSliceStore = getIsSliceStore();
+		Object.assign(store, {
+			name,
+			share: share ?? false,
+			setState,
+			getState,
+			subscribe,
+			destroy,
+			apply: apply$1,
+			isSliceStore,
+			getPureState
+		});
+		const middlewareStore = applyMiddlewares(store, options.middlewares ?? []);
+		if (middlewareStore !== store) Object.assign(store, middlewareStore);
+		internal.assertAlive?.("store initialization");
+		if (validatePatches && store.patch) {
+			const patch = store.patch.bind(store);
+			store.patch = (options) => {
+				const result = patch(options);
+				validatePatches(result.patches);
+				return result;
+			};
+		}
+		const initialState = getInitialState(store, createState, internal);
+		internal.assertAlive?.("store initialization");
+		internal.sharedActionPaths = runtime.collectActionPaths?.(initialState, store.isSliceStore);
+		if (!internal.getTransportState) runtime.validateInitialState?.(initialState, store.isSliceStore);
+		store.getInitialState = () => initialState;
+		internal.rootState = getRawState(store, internal, initialState, options, runtime.clientAction);
+		if (validatePatches && store.apply !== apply$1) {
+			const applyWithAdapter = store.apply.bind(store);
+			store.apply = (state, patches) => {
+				internal.assertAlive?.("apply");
+				internal.assertMutationAllowed?.("apply");
+				if (typeof state !== "undefined" && state !== internal.rootState && state !== internal.module) validateReplacementSource?.(state);
+				if (patches) {
+					validatePatches(patches);
+					assertSafePatches(patches, "store.apply()");
+				}
+				applyWithAdapter(state, patches);
+			};
+		}
+		internal.stateSchema = createStateSchema(internal.rootState, store.isSliceStore);
+		validateState?.(internal.getTransportState?.() ?? internal.rootState);
+		return {
+			store,
+			internal
+		};
+	} catch (error) {
+		try {
+			store.destroy?.();
+		} catch (destroyError) {
+			if (process.env.NODE_ENV === "development") console.error(destroyError);
+		}
+		releaseStoreName();
+		throw error;
+	}
+};
+//#endregion
+//#region packages/core/src/wrapStore.ts
+/**
+* Convert a store object into Coaction's callable store shape.
+*
+* @remarks
+* Framework bindings use this to attach selector-aware readers while
+* preserving the underlying store API on the returned function object. Most
+* applications should use a public `create` entry instead of calling
+* `wrapStore()` directly. Framework authors import this helper from
+* `coaction/local` or `coaction/adapter`.
+*/
+const wrapStore = (store, getState = () => store.getState()) => {
+	const { name, ..._store } = store;
+	return Object.assign({ [name]: (...args) => getState(...args) }[name], _store);
+};
+//#endregion
+//#region packages/core/src/createLocal.ts
+/**
+* Create a store without linking the shared transport runtime.
+*
+* @remarks
+* The public `coaction/local` entry exports this implementation as `create`.
+* `createLocal` is only its internal and documentation name; it is not
+* exported by the root `coaction` entry.
+*/
+const createLocal = (createState, options = {}) => {
+	for (const key of [
+		"clientTransport",
+		"executeSyncTimeoutMs",
+		"transport",
+		"transportPolicy",
+		"worker",
+		"workerType"
+	]) if (Object.hasOwnProperty.call(options, key)) throw new Error(`Option '${key}' requires the coaction/shared entry point.`);
+	const { store, internal } = createStore(createState, options);
+	try {
+		markStoreReady(store);
+		internal.assertAlive?.("store initialization");
+	} catch (error) {
+		try {
+			store.destroy();
+		} catch (destroyError) {
+			if (process.env.NODE_ENV === "development") console.error(destroyError);
+		}
+		throw error;
+	}
+	return wrapStore(store);
+};
+//#endregion
+export { computed, createLocal as create, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, onStoreReady, signal, startBatch, trigger, wrapStore };