coaction 2.1.0 → 3.0.0

package/dist/shared.js

@@ -0,0 +1,1976 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let data_transport = require("data-transport");
+let alien_signals = require("alien-signals");
+let mutative = require("mutative");
+//#region packages/core/src/lifecycle.ts
+const reportLifecycleError = (error) => {
+	if (process.env.NODE_ENV === "development") console.error(error);
+};
+const tryDestroyStore = (store) => {
+	try {
+		store.destroy?.();
+	} catch (error) {
+		reportLifecycleError(error);
+	}
+};
+const failStoreSetup = (store, error) => {
+	tryDestroyStore(store);
+	throw error;
+};
+const failTransportInitialization = (transport, error) => {
+	try {
+		transport?.dispose?.();
+	} catch (disposeError) {
+		reportLifecycleError(disposeError);
+	}
+	throw error;
+};
+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/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 isStateSchemaError = (error) => error instanceof StateSchemaError || error instanceof Error && 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 = (0, alien_signals.computed)(() => 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 = (0, alien_signals.computed)(() => runComputedRead(internal, () => getter.call(receiver)));
+			accessors.set(receiver, accessor);
+		}
+		return accessor();
+	};
+};
+const createTrackedStateReader = (internal, read, initialValue) => {
+	const slotSignal = (0, alien_signals.signal)(initialValue);
+	const slotVersionSignal = (0, alien_signals.signal)(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;
+	(0, alien_signals.startBatch)();
+	try {
+		internal.signalSlots.forEach((slot) => slot.refresh());
+	} finally {
+		(0, alien_signals.endBatch)();
+	}
+};
+//#endregion
+//#region packages/core/src/sharedState.ts
+const formatPath = (path) => path.length ? path.map((key) => String(key)).join(".") : "<root>";
+const unsupported = (label, path) => {
+	throw new TypeError(`${label} is not supported in shared store mode because transport synchronization uses JSON. Found unsupported value at ${formatPath(path)}.`);
+};
+const getDescriptors = (value, path) => {
+	try {
+		return Object.getOwnPropertyDescriptors(value);
+	} catch {
+		return unsupported("Uninspectable state", path);
+	}
+};
+const getPrototype = (value, path) => {
+	try {
+		return Object.getPrototypeOf(value);
+	} catch {
+		return unsupported("Uninspectable state prototype", path);
+	}
+};
+const assertNoInheritedToJson = (prototype, path) => {
+	let current = prototype;
+	while (current) {
+		let descriptor;
+		try {
+			descriptor = Object.getOwnPropertyDescriptor(current, "toJSON");
+		} catch {
+			unsupported("Uninspectable inherited toJSON state", path);
+		}
+		if (descriptor) {
+			if (!Object.prototype.hasOwnProperty.call(descriptor, "value") || typeof descriptor.value === "function") unsupported("Inherited toJSON state", path);
+			return;
+		}
+		current = getPrototype(current, path);
+	}
+};
+const isArrayIndex = (key, length) => {
+	const index = Number(key);
+	return key !== "" && Number.isSafeInteger(index) && index >= 0 && index < length && String(index) === key;
+};
+const pushDataProperty = (work, descriptor, key, path, actionRoot = false) => {
+	const nextPath = [...path, key];
+	if (!descriptor) return unsupported("Sparse array state", nextPath);
+	if (!descriptor.enumerable) return unsupported("Non-enumerable data state", nextPath);
+	if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) return unsupported("Accessor-backed state", nextPath);
+	work.push({
+		actionRoot,
+		path: nextPath,
+		value: descriptor.value
+	});
+};
+const assertSharedJsonWork = (work, isSliceStore = false) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	while (work.length) {
+		const { actionRoot = false, path, value } = work.pop();
+		if (value === null) continue;
+		switch (typeof value) {
+			case "string":
+			case "boolean": continue;
+			case "number":
+				if (!Number.isFinite(value)) unsupported("NaN or infinite number state", path);
+				if (Object.is(value, -0)) unsupported("Negative zero state", path);
+				continue;
+			case "bigint": unsupported("BigInt-valued state", path);
+			case "undefined": unsupported("Undefined-valued state", path);
+			case "function": unsupported("Function-valued state", path);
+			case "symbol": throw new TypeError(`Symbol-valued state is not supported in shared store mode because transport synchronization uses JSON. Found symbol value at ${formatPath(path)}.`);
+			default: break;
+		}
+		const object = value;
+		if (seen.has(object)) unsupported("Repeated state reference", path);
+		seen.add(object);
+		const descriptors = getDescriptors(object, path);
+		if (Array.isArray(object)) {
+			const prototype = getPrototype(object, path);
+			if (prototype !== Array.prototype) unsupported("Non-plain array state", path);
+			assertNoInheritedToJson(prototype, path);
+			const length = descriptors.length?.value;
+			if (!Number.isSafeInteger(length) || length < 0) unsupported("Invalid array state", path);
+			for (const key of Reflect.ownKeys(descriptors)) {
+				if (key === "length") continue;
+				if (typeof key === "symbol") throw new TypeError(`Symbol-keyed state is not supported in shared store mode because transport synchronization uses JSON and string action paths. Found symbol key at ${formatPath([...path, key])}.`);
+				if (!isArrayIndex(key, length)) unsupported("Non-index array property state", [...path, key]);
+			}
+			for (let index = 0; index < length; index += 1) pushDataProperty(work, descriptors[index], index, path);
+			continue;
+		}
+		const prototype = getPrototype(object, path);
+		if (prototype !== Object.prototype && prototype !== null) unsupported("Non-plain object state", path);
+		assertNoInheritedToJson(prototype, path);
+		for (const key of Reflect.ownKeys(descriptors)) {
+			if (typeof key === "symbol") throw new TypeError(`Symbol-keyed state is not supported in shared store mode because transport synchronization uses JSON and string action paths. Found symbol key at ${formatPath([...path, key])}.`);
+			if (isUnsafeKey(key)) unsupported("Unsafe-keyed state", [...path, key]);
+			const descriptor = descriptors[key];
+			if (actionRoot && descriptor) {
+				const isDataProperty = Object.prototype.hasOwnProperty.call(descriptor, "value");
+				if (isDataProperty && typeof descriptor.value === "function") continue;
+				if (actionRoot === "initial" && (!isDataProperty || descriptor.value instanceof Computed)) continue;
+			}
+			pushDataProperty(work, descriptor, key, path, isSliceStore && path.length === 0 ? "initial" : false);
+		}
+	}
+};
+const assertSharedJsonValue = (root) => {
+	assertSharedJsonWork([{
+		path: [],
+		value: root
+	}]);
+};
+const validateSharedInitialState = (root, isSliceStore = false) => {
+	assertSharedJsonWork([{
+		actionRoot: isSliceStore ? false : "initial",
+		path: [],
+		value: root
+	}], isSliceStore);
+};
+const validateSharedReplacementSource = (root) => {
+	if (typeof root !== "object" || root === null || Array.isArray(root)) unsupported("Non-record replacement state", []);
+	assertSharedJsonWork([{
+		actionRoot: "replacement",
+		path: [],
+		value: root
+	}]);
+};
+const encodeSharedJson = (value) => {
+	assertSharedJsonValue(value);
+	const encoded = JSON.stringify(value);
+	if (typeof encoded !== "string") throw new TypeError("Shared transport value could not be encoded as JSON.");
+	return encoded;
+};
+const decodeSharedJson = (encoded) => {
+	if (typeof encoded !== "string") throw new TypeError("Shared transport payload must be a JSON string.");
+	let value;
+	try {
+		value = JSON.parse(encoded);
+	} catch {
+		throw new TypeError("Shared transport payload is not valid JSON.");
+	}
+	assertSharedJsonValue(value);
+	return value;
+};
+const validateSharedActionPaths = (state, isSliceStore = false) => {
+	const actions = /* @__PURE__ */ new Set();
+	const work = [{
+		actionRoot: !isSliceStore,
+		path: [],
+		value: state
+	}];
+	const seen = /* @__PURE__ */ new WeakSet();
+	while (work.length) {
+		const { actionRoot, path, value } = work.pop();
+		if (typeof value !== "object" || value === null || seen.has(value)) continue;
+		seen.add(value);
+		const descriptors = getDescriptors(value, path);
+		for (const key of Reflect.ownKeys(descriptors)) {
+			if (typeof key === "symbol") throw new TypeError(`Symbol-keyed state is not supported in shared store mode because transport synchronization uses JSON and string action paths. Found symbol key at ${formatPath([...path, key])}.`);
+			const descriptor = descriptors[key];
+			if (descriptor && Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+				const nextPath = [...path, key];
+				if (actionRoot && typeof descriptor.value === "function") {
+					actions.add(JSON.stringify(nextPath));
+					continue;
+				}
+				work.push({
+					actionRoot: isSliceStore && path.length === 0,
+					path: nextPath,
+					value: descriptor.value
+				});
+			}
+		}
+	}
+	return actions;
+};
+const validateSharedStateSerializable = assertSharedJsonValue;
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const asRecord = (value, message) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(message);
+	return value;
+};
+const decodeMessage = (encoded, type) => {
+	const message = asRecord(decodeSharedJson(encoded), "Invalid transport message");
+	if (message.v !== 1 || message.type !== type) throw new TypeError("Invalid transport message");
+	return message;
+};
+const readEpoch = (message) => {
+	if (typeof message.epoch !== "string" || message.epoch.length === 0) throw new TypeError("Invalid transport epoch");
+	return message.epoch;
+};
+const readSequence = (message) => {
+	if (typeof message.sequence !== "number" || !Number.isSafeInteger(message.sequence) || message.sequence < 0) throw new TypeError("Invalid transport sequence");
+	return message.sequence;
+};
+const readAction = (value) => {
+	if (!Array.isArray(value) || value.length === 0 || value.some((key) => typeof key !== "string" || isUnsafePathSegment(key))) throw new TypeError("Invalid transport action");
+	return [...value];
+};
+const readPath = (value, { allowUnsafe = false } = {}) => {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError("Invalid transport patch path");
+	const path = [];
+	for (const segment of value) {
+		if (typeof segment !== "string" && (typeof segment !== "number" || !Number.isSafeInteger(segment) || segment < 0) || !allowUnsafe && isUnsafePathSegment(segment)) throw new TypeError("Invalid transport patch path");
+		path.push(segment);
+	}
+	return path;
+};
+const readPatches = (value, options = {}) => {
+	if (!Array.isArray(value)) throw new TypeError("Invalid transport patches");
+	return value.map((candidate) => {
+		const patch = asRecord(candidate, "Invalid transport patch");
+		const path = readPath(patch.path, { allowUnsafe: options.allowUnsafePaths });
+		if (patch.op === "remove") {
+			if (hasOwn(patch, "value")) throw new TypeError("Invalid remove patch");
+			return {
+				op: "remove",
+				path
+			};
+		}
+		if (patch.op !== "add" && patch.op !== "replace" || !hasOwn(patch, "value")) throw new TypeError("Invalid transport patch");
+		return {
+			op: patch.op,
+			path,
+			value: patch.value
+		};
+	});
+};
+const validateUpdatePatches = (patches) => {
+	assertSharedJsonValue(patches);
+	readPatches(patches, { allowUnsafePaths: true });
+};
+const encodeExecuteRequest = (action, args) => encodeSharedJson({
+	action: readAction([...action]),
+	args,
+	type: "execute",
+	v: 1
+});
+const decodeExecuteRequest = (encoded) => {
+	const message = decodeMessage(encoded, "execute");
+	if (!Array.isArray(message.args)) throw new TypeError("Invalid transport arguments");
+	return {
+		action: readAction(message.action),
+		args: [...message.args]
+	};
+};
+const encodeExecuteResponse = (response) => encodeSharedJson({
+	...response,
+	type: "execute-result",
+	v: 1
+});
+const decodeExecuteResponse = (encoded) => {
+	const message = decodeMessage(encoded, "execute-result");
+	const base = {
+		epoch: readEpoch(message),
+		sequence: readSequence(message)
+	};
+	if (message.ok === true) return hasOwn(message, "value") ? {
+		...base,
+		ok: true,
+		value: message.value
+	} : {
+		...base,
+		ok: true
+	};
+	if (message.ok !== false || typeof message.error !== "string" || message.error.length === 0) throw new TypeError("Invalid execute response");
+	return {
+		...base,
+		error: message.error,
+		ok: false
+	};
+};
+const encodeFullSyncRequest = () => encodeSharedJson({
+	type: "full-sync",
+	v: 1
+});
+const decodeFullSyncRequest = (encoded) => {
+	decodeMessage(encoded, "full-sync");
+};
+const encodeFullSyncResponse = (response) => encodeSharedJson({
+	...response,
+	type: "full-sync-result",
+	v: 1
+});
+const decodeFullSyncResponse = (encoded) => {
+	const message = decodeMessage(encoded, "full-sync-result");
+	return {
+		epoch: readEpoch(message),
+		sequence: readSequence(message),
+		state: asRecord(message.state, "Invalid fullSync state")
+	};
+};
+const encodeUpdateMessage = (epoch, sequence, patches) => {
+	return encodeSharedJson({
+		epoch,
+		patches: readPatches(patches.map((patch) => patch.op === "remove" ? {
+			op: patch.op,
+			path: patch.path
+		} : {
+			op: patch.op,
+			path: patch.path,
+			value: patch.value
+		})),
+		sequence,
+		type: "update",
+		v: 1
+	});
+};
+const decodeUpdateMessage = (encoded) => {
+	const message = decodeMessage(encoded, "update");
+	return {
+		epoch: readEpoch(message),
+		patches: readPatches(message.patches),
+		sequence: readSequence(message)
+	};
+};
+//#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/asyncClientStore.ts
+const clientApplyErrorMessage = "apply() cannot be called in the client store. Client stores are mirrors; use a store method to update the main store instead.";
+const createAsyncClientStore = (createStore, options) => {
+	let createdStore;
+	try {
+		createdStore = createStore({ share: "client" });
+	} catch (error) {
+		return failTransportInitialization(options.clientTransport, error);
+	}
+	const { store, internal } = createdStore;
+	let canApplyClientState = false;
+	const previousAssertMutationAllowed = internal.assertMutationAllowed;
+	internal.assertMutationAllowed = (operation) => {
+		if (operation === "apply") {
+			if (!canApplyClientState) throw new Error(clientApplyErrorMessage);
+			canApplyClientState = false;
+		}
+		previousAssertMutationAllowed?.(operation);
+	};
+	const baseApply = store.apply.bind(store);
+	store.apply = () => {
+		throw new Error(clientApplyErrorMessage);
+	};
+	internal.applyClientState = (...args) => {
+		canApplyClientState = true;
+		try {
+			baseApply(...args);
+		} finally {
+			canApplyClientState = false;
+		}
+	};
+	const isSharedWorker = typeof SharedWorker !== "undefined" && options.worker instanceof SharedWorker;
+	let transport;
+	try {
+		transport = options.worker ? (0, data_transport.createTransport)(isSharedWorker ? "SharedWorkerClient" : "WebWorkerClient", {
+			worker: options.worker,
+			prefix: store.name
+		}) : options.clientTransport;
+	} catch (error) {
+		return failStoreSetup(store, error);
+	}
+	if (!transport) return failStoreSetup(store, /* @__PURE__ */ new Error("transport is required"));
+	try {
+		store.transport = transport;
+		if (typeof transport.onConnect !== "function") throw new Error("transport.onConnect is required");
+	} catch (error) {
+		return failStoreSetup(store, error);
+	}
+	const destroyedMarker = Symbol("destroyed client transport");
+	let resolveDestroyed;
+	const destroyedSignal = new Promise((resolve) => {
+		resolveDestroyed = () => resolve(destroyedMarker);
+	});
+	const disposers = /* @__PURE__ */ new Set();
+	let destroyed = false;
+	let connectGeneration = 0;
+	let connectSync = null;
+	let syncTail = Promise.resolve();
+	const registerDisposer = (value) => {
+		if (typeof value === "function") disposers.add(value);
+	};
+	const cleanup = () => {
+		if (destroyed) return;
+		destroyed = true;
+		connectGeneration += 1;
+		resolveDestroyed();
+		const callbacks = [...disposers];
+		disposers.clear();
+		for (const dispose of callbacks) try {
+			dispose();
+		} catch (error) {
+			reportLifecycleError(error);
+		}
+	};
+	const awaitActive = async (value) => {
+		const result = await Promise.race([Promise.resolve(value), destroyedSignal]);
+		if (result === destroyedMarker) throw new Error("Client transport was destroyed");
+		return result;
+	};
+	internal.awaitClientTransport = awaitActive;
+	const applyFullSync = (state, epoch, sequence) => {
+		const previousEpoch = internal.transportEpoch;
+		const previousSequence = internal.sequence;
+		internal.transportEpoch = epoch;
+		internal.sequence = sequence;
+		try {
+			internal.applyClientState(state);
+		} catch (error) {
+			internal.transportEpoch = previousEpoch;
+			internal.sequence = previousSequence;
+			throw error;
+		}
+	};
+	const fullSync = (expectedEpoch, minimumSequence = 0, generation = connectGeneration) => {
+		const execute = async () => {
+			if (destroyed || generation !== connectGeneration) return;
+			const encoded = await awaitActive(transport.emit("fullSync", encodeFullSyncRequest()));
+			if (destroyed || generation !== connectGeneration) return;
+			const snapshot = decodeFullSyncResponse(encoded);
+			if (expectedEpoch && snapshot.epoch !== expectedEpoch) throw new Error("Mismatched fullSync epoch");
+			if (snapshot.sequence < minimumSequence) throw new Error("Stale fullSync sequence");
+			if (snapshot.epoch === internal.transportEpoch && snapshot.sequence < internal.sequence) return;
+			applyFullSync(snapshot.state, snapshot.epoch, snapshot.sequence);
+		};
+		const run = syncTail.then(execute, execute);
+		syncTail = run.then(() => void 0, () => void 0);
+		return run;
+	};
+	internal.syncClientState = (expectedEpoch, minimumSequence) => fullSync(expectedEpoch, minimumSequence);
+	const applyUpdate = (update) => {
+		const previousEpoch = internal.transportEpoch;
+		const previousSequence = internal.sequence;
+		internal.transportEpoch = update.epoch;
+		internal.sequence = update.sequence;
+		try {
+			internal.applyClientState(void 0, update.patches);
+		} catch (error) {
+			internal.transportEpoch = previousEpoch;
+			internal.sequence = previousSequence;
+			throw error;
+		}
+	};
+	const handleUpdate = async (encoded) => {
+		if (destroyed) return;
+		const generation = connectGeneration;
+		const update = decodeUpdateMessage(encoded);
+		if (connectSync) await connectSync;
+		if (destroyed || generation !== connectGeneration) return;
+		if (update.epoch !== internal.transportEpoch) await fullSync(update.epoch, 0, generation);
+		if (destroyed || generation !== connectGeneration) return;
+		if (update.epoch !== internal.transportEpoch) throw new Error("Mismatched update epoch");
+		if (update.sequence <= internal.sequence) return;
+		if (update.sequence === internal.sequence + 1) {
+			applyUpdate(update);
+			return;
+		}
+		await fullSync(update.epoch, update.sequence, generation);
+	};
+	internal.destroyCallbacks?.add(cleanup);
+	try {
+		registerDisposer(transport.listen("update", async (encoded) => {
+			try {
+				await handleUpdate(encoded);
+			} catch (error) {
+				if (!destroyed) {
+					try {
+						await fullSync();
+					} catch (syncError) {
+						reportLifecycleError(syncError);
+					}
+					reportLifecycleError(error);
+				}
+			}
+		}));
+		registerDisposer(transport.onConnect(() => {
+			const pending = fullSync(void 0, 0, ++connectGeneration).finally(() => {
+				if (connectSync === pending) connectSync = null;
+			});
+			connectSync = pending;
+			pending.catch(reportLifecycleError);
+			return pending;
+		}));
+		markStoreReady(store);
+		internal.assertAlive?.("store initialization");
+	} catch (error) {
+		return failStoreSetup(store, error);
+	}
+	return wrapStore(store, () => store.getState());
+};
+const emit = (store, internal, patches) => {
+	if (!store.transport || !patches?.length || !internal.transportEpoch) return;
+	const sequence = internal.sequence + 1;
+	const encoded = encodeUpdateMessage(internal.transportEpoch, sequence, patches);
+	internal.sequence = sequence;
+	try {
+		const pending = store.transport.emit({
+			name: "update",
+			respond: false
+		}, encoded);
+		Promise.resolve(pending).catch(reportLifecycleError);
+	} catch (error) {
+		reportLifecycleError(error);
+	}
+};
+//#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;
+};
+//#endregion
+//#region packages/core/src/constant.ts
+const WorkerType = getGlobal().SharedWorkerGlobalScope ? "SharedWorkerInternal" : globalThis.WorkerGlobalScope ? "WebWorkerInternal" : null;
+const bindSymbol = Symbol("bind");
+//#endregion
+//#region packages/core/src/getRawStateClientAction.ts
+/**
+* The authority changed while a remote action was in flight, so its side-effect
+* outcome cannot be determined safely from the current client mirror.
+*/
+var ActionAuthorityChangedError = class extends Error {
+	code = "COACTION_ACTION_AUTHORITY_CHANGED";
+	outcome = "unknown";
+	constructor(action) {
+		super(`The authority changed while action '${action}' was in flight. The action may have completed on the previous authority; retry only if it is idempotent.`);
+		this.name = "ActionAuthorityChangedError";
+	}
+};
+const createClientAction = ({ clientExecuteSyncTimeoutMs, internal, key, store, sliceKey }) => {
+	return (...args) => {
+		internal.assertAlive?.(`action ${key}`);
+		let actionId;
+		let done;
+		if (store.trace) {
+			actionId = uuid();
+			store.trace({
+				method: key,
+				parameters: args,
+				id: actionId,
+				sliceKey
+			});
+			done = (result) => {
+				store.trace({
+					method: 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;
+			}
+		};
+		if (typeof sliceKey === "symbol") throw new Error("Symbol-keyed slice actions are not supported in client store mode.");
+		const encoded = encodeExecuteRequest(typeof sliceKey === "undefined" ? [key] : [String(sliceKey), key], args);
+		const requestEpoch = internal.transportEpoch;
+		return traceAction(() => {
+			const emitted = store.transport.emit("execute", encoded);
+			return (internal.awaitClientTransport ? internal.awaitClientTransport(emitted) : emitted).then(async (payload) => {
+				const response = decodeExecuteResponse(payload);
+				internal.assertAlive?.(`action ${key}`);
+				const syncClientState = internal.syncClientState;
+				if (!syncClientState) throw new Error("Client fullSync is not available");
+				if (internal.transportEpoch !== requestEpoch && response.epoch !== internal.transportEpoch) throw new ActionAuthorityChangedError(key);
+				if (response.epoch !== internal.transportEpoch) {
+					await syncClientState(response.epoch, response.sequence);
+					internal.assertAlive?.(`action ${key}`);
+				} else if (response.sequence > internal.sequence) {
+					await new Promise((resolve, reject) => {
+						let settled = false;
+						let unsubscribe = () => {};
+						let timeout;
+						const cancel = () => finish(/* @__PURE__ */ new Error("Client transport was destroyed"));
+						const finish = (error) => {
+							if (settled) return;
+							settled = true;
+							unsubscribe();
+							internal.destroyCallbacks?.delete(cancel);
+							if (timeout) clearTimeout(timeout);
+							if (typeof error === "undefined") resolve();
+							else reject(error);
+						};
+						unsubscribe = store.subscribe(() => {
+							if (internal.transportEpoch === response.epoch && internal.sequence >= response.sequence) finish();
+						});
+						internal.destroyCallbacks?.add(cancel);
+						timeout = setTimeout(() => {
+							syncClientState(response.epoch, response.sequence).then(() => finish(), (error) => finish(error));
+						}, clientExecuteSyncTimeoutMs);
+						if (internal.transportEpoch === response.epoch && internal.sequence >= response.sequence) finish();
+					});
+					internal.assertAlive?.(`action ${key}`);
+				}
+				if (!response.ok) throw new Error(response.error);
+				return response.value;
+			});
+		});
+	};
+};
+//#endregion
+//#region packages/core/src/handleMainTransport.ts
+const publicErrorMessages = /* @__PURE__ */ new Set([
+	"Remote action is not allowed",
+	"The function is not found",
+	"Transport request is not authorized",
+	"Transport request was cancelled after store destroy"
+]);
+const getErrorMessage = async (error, request, policy) => {
+	if (error instanceof Error && publicErrorMessages.has(error.message)) return error.message;
+	if (request && policy?.mapError) try {
+		const message = await policy.mapError(error, request);
+		if (typeof message === "string" && message) return message;
+	} catch (mapError) {
+		if (process.env.NODE_ENV === "development") console.error(mapError);
+	}
+	return "Remote action failed";
+};
+const handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches, policy) => {
+	const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? (0, data_transport.createTransport)(workerType, { prefix: store.name }) : void 0);
+	if (!transport) return;
+	if (checkEnablePatches) throw new Error("enablePatches: true is required for the transport");
+	const epoch = uuid();
+	internal.transportEpoch = epoch;
+	let destroyed = false;
+	const disposers = /* @__PURE__ */ new Set();
+	const registerDisposer = (value) => {
+		if (typeof value === "function") disposers.add(value);
+	};
+	const cleanup = () => {
+		if (destroyed) return;
+		destroyed = true;
+		const callbacks = [...disposers];
+		disposers.clear();
+		for (const dispose of callbacks) try {
+			dispose();
+		} catch (error) {
+			if (process.env.NODE_ENV === "development") console.error(error);
+		}
+	};
+	const assertActive = () => {
+		if (destroyed) throw new Error("Transport request was cancelled after store destroy");
+	};
+	store.transport = transport;
+	internal.emitPatches = (patches) => emit(store, internal, patches);
+	internal.destroyCallbacks?.add(cleanup);
+	try {
+		registerDisposer(transport.listen("execute", async (encoded) => {
+			let policyRequest;
+			try {
+				assertActive();
+				const request = decodeExecuteRequest(encoded);
+				if (!internal.sharedActionPaths?.has(JSON.stringify(request.action))) throw new Error("Remote action is not allowed");
+				if (policy?.allowedActions && !policy.allowedActions.some((allowed) => allowed.length === request.action.length && allowed.every((key, index) => key === request.action[index]))) throw new Error("Remote action is not allowed");
+				policyRequest = {
+					...request,
+					type: "execute"
+				};
+				if (policy?.authorize && await policy.authorize(policyRequest) !== true) throw new Error("Transport request is not authorized");
+				assertActive();
+				let action = store.getState();
+				let receiver;
+				for (const key of request.action) {
+					if (isUnsafePathSegment(key) || typeof action !== "object" && typeof action !== "function" || action === null || !Object.prototype.hasOwnProperty.call(action, key)) throw new Error("The function is not found");
+					receiver = action;
+					action = action[key];
+				}
+				if (typeof action !== "function") throw new Error("The function is not found");
+				const value = await Reflect.apply(action, receiver, request.args);
+				assertActive();
+				return encodeExecuteResponse({
+					epoch,
+					ok: true,
+					sequence: internal.sequence,
+					...typeof value === "undefined" ? {} : { value }
+				});
+			} catch (error) {
+				if (process.env.NODE_ENV === "development") console.error(error);
+				return encodeExecuteResponse({
+					epoch,
+					error: await getErrorMessage(error, policyRequest, policy),
+					ok: false,
+					sequence: internal.sequence
+				});
+			}
+		}));
+		registerDisposer(transport.listen("fullSync", async (encoded) => {
+			assertActive();
+			decodeFullSyncRequest(encoded);
+			if (policy?.authorize && await policy.authorize({ type: "fullSync" }) !== true) throw new Error("Transport request is not authorized");
+			assertActive();
+			const state = internal.getTransportState?.() ?? internal.rootState;
+			validateSharedStateSerializable(state);
+			if (typeof state !== "object" || state === null || Array.isArray(state)) throw new TypeError("Shared store state must be a JSON object");
+			return encodeFullSyncResponse({
+				epoch,
+				sequence: internal.sequence,
+				state
+			});
+		}));
+	} catch (error) {
+		internal.destroyCallbacks?.delete(cleanup);
+		cleanup();
+		store.transport = void 0;
+		try {
+			transport.dispose?.();
+		} catch (disposeError) {
+			if (process.env.NODE_ENV === "development") console.error(disposeError);
+		}
+		throw error;
+	}
+};
+//#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/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] = (0, mutative.create)(internal.rootState, { enablePatches: true });
+						internal.finalizeDraft = finalize;
+						internal.rootState = draft;
+					}
+				};
+				const isDrafted = (0, mutative.isDraft)(internal.rootState);
+				if (isDrafted) handleResult();
+				internal.backupState = internal.rootState;
+				const [draft, finalize] = (0, mutative.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 = (0, mutative.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 = (0, mutative.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, (0, mutative.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 && (0, mutative.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] = (0, mutative.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 ? (0, mutative.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 = (state = internal.rootState, patches) => applyState(state, patches);
+		internal.applyValidatedPatches = (state, patches, skipFinalValidation) => {
+			if (store.apply !== apply) {
+				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,
+			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) {
+			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/create.ts
+const isMainWorkerType = (workerType) => workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal";
+const isClientWorkerType = (workerType) => workerType === "SharedWorkerClient" || workerType === "WebWorkerClient";
+const validateCreateModeOptions = (options) => {
+	const storeTransport = options.transport;
+	const clientTransport = options.clientTransport;
+	const worker = options.worker;
+	const explicitWorkerType = options.workerType;
+	if (storeTransport && clientTransport) throw new Error("transport and clientTransport cannot be used together, please use one authority model per store.");
+	if (storeTransport && worker) throw new Error("transport and worker cannot be used together, please use one authority model per store.");
+	if (clientTransport && worker) throw new Error("clientTransport and worker cannot be used together, please use one client transport source.");
+	if (isMainWorkerType(explicitWorkerType) && (clientTransport || worker)) throw new Error("main workerType cannot be combined with client transport settings.");
+	if (isClientWorkerType(explicitWorkerType) && storeTransport) throw new Error("client workerType cannot be combined with transport.");
+};
+/**
+* Create a local store, the main side of a shared store, or a client mirror of
+* a shared store.
+*
+* @remarks
+* Prefer the static `coaction/local` entry when transport support is not
+* required. It excludes the JSON protocol and reconnect runtime from the
+* consumer dependency graph.
+*/
+const create = (createState, options = {}) => {
+	const checkEnablePatches = Object.hasOwnProperty.call(options, "enablePatches") && !options.enablePatches;
+	validateCreateModeOptions(options);
+	const workerType = options.workerType ?? WorkerType;
+	const storeTransport = options.transport;
+	const share = isMainWorkerType(workerType) || storeTransport ? "main" : void 0;
+	const buildStore = ({ share }) => createStore(createState, options, {
+		share,
+		clientAction: share === "client" ? createClientAction : void 0,
+		collectActionPaths: share === "main" ? validateSharedActionPaths : void 0,
+		validateInitialState: share ? validateSharedInitialState : void 0,
+		validatePatches: share === "main" ? validateUpdatePatches : void 0,
+		validateReplacementSource: share ? validateSharedReplacementSource : void 0,
+		validateState: share ? validateSharedStateSerializable : void 0
+	});
+	if (options.clientTransport || options.worker || isClientWorkerType(options.workerType)) {
+		if (checkEnablePatches) throw new Error("enablePatches: true is required for the async store");
+		return wrapStore(createAsyncClientStore(buildStore, options));
+	}
+	if (share === "main" && checkEnablePatches) throw new Error("enablePatches: true is required for the transport");
+	let builtStore;
+	try {
+		builtStore = buildStore({ share });
+	} catch (error) {
+		return failTransportInitialization(storeTransport, error);
+	}
+	const { store, internal } = builtStore;
+	try {
+		handleMainTransport(store, internal, storeTransport, workerType, checkEnablePatches, options.transportPolicy);
+		markStoreReady(store);
+		internal.assertAlive?.("store initialization");
+	} catch (error) {
+		return failStoreSetup(store, error);
+	}
+	return wrapStore(store);
+};
+//#endregion
+exports.ActionAuthorityChangedError = ActionAuthorityChangedError;
+exports.StateSchemaError = StateSchemaError;
+exports.UnsafePatchPathError = UnsafePatchPathError;
+exports.assertSafePatches = assertSafePatches;
+Object.defineProperty(exports, "computed", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.computed;
+	}
+});
+exports.create = create;
+Object.defineProperty(exports, "effect", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.effect;
+	}
+});
+Object.defineProperty(exports, "effectScope", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.effectScope;
+	}
+});
+Object.defineProperty(exports, "endBatch", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.endBatch;
+	}
+});
+Object.defineProperty(exports, "isComputed", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isComputed;
+	}
+});
+Object.defineProperty(exports, "isEffect", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isEffect;
+	}
+});
+Object.defineProperty(exports, "isEffectScope", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isEffectScope;
+	}
+});
+Object.defineProperty(exports, "isSignal", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isSignal;
+	}
+});
+exports.isStateSchemaError = isStateSchemaError;
+exports.onStoreReady = onStoreReady;
+exports.sanitizeInitialStateValue = sanitizeInitialStateValue;
+exports.sanitizePatches = sanitizePatches;
+exports.sanitizeReplacementState = sanitizeReplacementState;
+Object.defineProperty(exports, "signal", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.signal;
+	}
+});
+Object.defineProperty(exports, "startBatch", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.startBatch;
+	}
+});
+Object.defineProperty(exports, "trigger", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.trigger;
+	}
+});