coaction 2.0.0 → 3.0.0

package/dist/index.mjs

@@ -1,34 +1,53 @@
-import { apply, create as create$1, isDraft } from "mutative";
 import { createTransport } from "data-transport";
-import { computed, computed as computed$1, effect, effectScope, endBatch, endBatch as endBatch$1, isComputed, isEffect, isEffectScope, isSignal, setActiveSub, signal, signal as signal$1, startBatch, startBatch as startBatch$1, trigger } from "alien-signals";
-import * as alienSignalsSystem from "alien-signals/system";
-//#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;
+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";
+import { apply, create as create$1, isDraft } from "mutative";
+//#region packages/core/src/lifecycle.ts
+const reportLifecycleError = (error) => {
+	if (process.env.NODE_ENV === "development") console.error(error);
 };
-//#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/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 call {@link create} instead of using `wrapStore()`
-* directly.
-*/
-const wrapStore = (store, getState = () => store.getState()) => {
-	const { name, ..._store } = store;
-	return Object.assign({ [name]: (...args) => getState(...args) }[name], _store);
+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
@@ -38,13 +57,40 @@ const isEqual = (x, 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 sanitizePatches = (patches) => patches?.filter((patch) => !hasUnsafePatchPath(patch.path)).map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
-	...patch,
-	value: sanitizeReplacementState(patch.value)
-} : patch);
+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;
@@ -53,7 +99,59 @@ const getOwnEnumerableKeys = (source) => {
 	if (typeof source !== "object" || source === null) return [];
 	return Reflect.ownKeys(source).filter((key) => Object.prototype.propertyIsEnumerable.call(source, key));
 };
-const isArrayIndexKey$1 = (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;
@@ -62,20 +160,6 @@ 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 replaceOwnEnumerable = (target, source) => {
-	const seen = /* @__PURE__ */ new WeakMap();
-	seen.set(source, target);
-	const nextKeys = /* @__PURE__ */ new Set();
-	for (const key of getOwnEnumerableKeys(source)) {
-		if (typeof key === "string" && isUnsafeKey(key)) continue;
-		if (typeof source[key] === "function") continue;
-		nextKeys.add(key);
-	}
-	for (const key of getOwnEnumerableKeys(target)) if (!nextKeys.has(key)) delete target[key];
-	nextKeys.forEach((key) => {
-		setOwnEnumerable(target, key, sanitizeReplacementState(source[key], seen));
-	});
-};
 const cloneOwnEnumerable = (source) => {
 	const target = {};
 	assignOwnEnumerable(target, source);
@@ -91,7 +175,7 @@ const sanitizeReplacementState = (source, seen = /* @__PURE__ */ new WeakMap())
 		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$1(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			if (isArrayIndexKey(key) || typeof key === "string" && isUnsafeKey(key)) continue;
 			const value = source[key];
 			if (typeof value === "function") continue;
 			setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
@@ -120,7 +204,7 @@ const sanitizeInitialStateValue = (source, seen = /* @__PURE__ */ new WeakMap())
 		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$1(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			if (isArrayIndexKey(key) || typeof key === "string" && isUnsafeKey(key)) continue;
 			setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
 		}
 		return target;
@@ -165,319 +249,632 @@ const uuid = () => {
 	});
 };
 //#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/sharedState.ts
-const formatPropertyPath = (path) => path.length ? path.map((key) => String(key)).join(".") : "<root>";
-const isPlainObject = (value) => {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
+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 isArrayIndexKey = (key, length) => {
-	if (key === "") return false;
+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 Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
-};
-const findSymbolKeyViolation = (value, path = [], seen = /* @__PURE__ */ new WeakSet()) => {
-	if (typeof value !== "object" || value === null) return;
-	if (seen.has(value)) return;
-	seen.add(value);
-	const descriptors = Object.getOwnPropertyDescriptors(value);
-	for (const key of getOwnEnumerableKeys(value)) {
-		const nextPath = [...path, key];
-		if (typeof key === "symbol") return {
-			type: "symbol-key",
-			path: nextPath
-		};
-		const descriptor = descriptors[key];
-		if (descriptor && Object.prototype.hasOwnProperty.call(descriptor, "value")) {
-			const violation = findSymbolKeyViolation(descriptor.value, nextPath, seen);
-			if (violation) return violation;
+	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 findJsonViolation = (value, path = [], ancestors = /* @__PURE__ */ new WeakSet()) => {
-	switch (typeof value) {
-		case "symbol": return {
-			type: "symbol-value",
-			path
-		};
-		case "bigint": return {
-			type: "bigint",
-			path
-		};
-		case "undefined": return {
-			type: "undefined",
-			path
-		};
-		case "function": return {
-			type: "function",
-			path
-		};
-		case "number": return Number.isFinite(value) ? void 0 : {
-			type: "non-finite-number",
-			path
-		};
-		default: break;
+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.");
 	}
-	if (typeof value !== "object" || value === null) return;
-	if (ancestors.has(value)) return {
-		type: "circular-reference",
-		path
-	};
-	if (Array.isArray(value)) {
-		ancestors.add(value);
-		for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) return {
-			type: "array-hole",
-			path: [...path, index]
-		};
-		for (const key of getOwnEnumerableKeys(value)) {
-			const nextPath = [...path, key];
-			if (typeof key === "symbol") return {
-				type: "symbol-key",
-				path: nextPath
-			};
-			if (!isArrayIndexKey(key, value.length)) return {
-				type: "array-property",
-				path: nextPath
-			};
-			const violation = findJsonViolation(value[Number(key)], nextPath, ancestors);
-			if (violation) return violation;
+	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
+				});
+			}
 		}
-		ancestors.delete(value);
-		return;
 	}
-	if (!isPlainObject(value)) return {
-		type: "non-plain-object",
-		path
+	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 (typeof value.toJSON === "function") return {
-		type: "to-json",
-		path
+	if (message.ok === true) return hasOwn(message, "value") ? {
+		...base,
+		ok: true,
+		value: message.value
+	} : {
+		...base,
+		ok: true
 	};
-	ancestors.add(value);
-	for (const key of getOwnEnumerableKeys(value)) {
-		const nextPath = [...path, key];
-		if (typeof key === "symbol") return {
-			type: "symbol-key",
-			path: nextPath
-		};
-		const child = value[key];
-		const violation = findJsonViolation(child, nextPath, ancestors);
-		if (violation) return violation;
-	}
-	ancestors.delete(value);
-};
-const getViolationLabel = (violation) => {
-	switch (violation.type) {
-		case "bigint": return "BigInt-valued state";
-		case "undefined": return "Undefined-valued state";
-		case "function": return "Function-valued state";
-		case "non-finite-number": return "NaN or infinite number state";
-		case "non-plain-object": return "Non-plain object state";
-		case "circular-reference": return "Circular state reference";
-		case "array-hole": return "Sparse array state";
-		case "array-property": return "Non-index array property state";
-		case "to-json": return "Custom toJSON state";
-		default: return;
-	}
+	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 validateSharedActionPaths = (state) => {
-	const violation = findSymbolKeyViolation(state);
-	if (!violation) return;
-	throw new Error(`Symbol-keyed state is not supported in shared store mode because transport synchronization uses JSON and string action paths. Found symbol key at ${formatPropertyPath(violation.path)}.`);
+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 validateSharedStateSerializable = (state) => {
-	const violation = findJsonViolation(state);
-	if (!violation) return;
-	if (violation.type === "symbol-key") throw new Error(`Symbol-keyed state is not supported in shared store mode because transport synchronization uses JSON and string action paths. Found symbol key at ${formatPropertyPath(violation.path)}.`);
-	if (violation.type === "symbol-value") throw new Error(`Symbol-valued state is not supported in shared store mode because transport synchronization uses JSON. Found symbol value at ${formatPropertyPath(violation.path)}.`);
-	throw new Error(`${getViolationLabel(violation)} is not supported in shared store mode because transport synchronization uses JSON. Found unsupported value at ${formatPropertyPath(violation.path)}.`);
+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/asyncClientStore.ts
-const parseFullSyncState$1 = (state) => {
-	const parsed = JSON.parse(state);
-	if (typeof parsed !== "object" || parsed === null) throw new Error("Invalid fullSync payload");
-	return sanitizeReplacementState(parsed);
+//#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, asyncStoreClientOption) => {
-	const { store: asyncClientStore, internal } = createStore({ share: "client" });
-	let isApplyingClientState = false;
+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" && !isApplyingClientState) throw new Error(clientApplyErrorMessage);
+		if (operation === "apply") {
+			if (!canApplyClientState) throw new Error(clientApplyErrorMessage);
+			canApplyClientState = false;
+		}
 		previousAssertMutationAllowed?.(operation);
 	};
-	const baseApply = asyncClientStore.apply.bind(asyncClientStore);
-	asyncClientStore.apply = (state, patches) => {
-		if (!isApplyingClientState) throw new Error(clientApplyErrorMessage);
-		return baseApply(state, patches);
+	const baseApply = store.apply.bind(store);
+	store.apply = () => {
+		throw new Error(clientApplyErrorMessage);
 	};
 	internal.applyClientState = (...args) => {
-		isApplyingClientState = true;
+		canApplyClientState = true;
 		try {
 			baseApply(...args);
 		} finally {
-			isApplyingClientState = false;
+			canApplyClientState = false;
 		}
 	};
-	const isSharedWorker = typeof SharedWorker !== "undefined" && asyncStoreClientOption.worker instanceof SharedWorker;
-	const transport = asyncStoreClientOption.worker ? createTransport(isSharedWorker ? "SharedWorkerClient" : "WebWorkerClient", {
-		worker: asyncStoreClientOption.worker,
-		prefix: asyncClientStore.name
-	}) : asyncStoreClientOption.clientTransport;
-	if (!transport) throw new Error("transport is required");
-	asyncClientStore.transport = transport;
-	let syncingPromise = null;
-	let awaitingReconnectSync = false;
-	let reconnectSequenceBaseline = null;
-	const fullSync = async (allowLowerSequence = false) => {
-		if (!syncingPromise) syncingPromise = (async () => {
-			const latest = await transport.emit("fullSync");
-			if (typeof latest !== "object" || latest === null || typeof latest.sequence !== "number" || typeof latest.state !== "string") throw new Error("Invalid fullSync payload");
-			const canApplyLowerSequence = allowLowerSequence && awaitingReconnectSync && reconnectSequenceBaseline !== null && reconnectSequenceBaseline === internal.sequence;
-			if (latest.sequence < internal.sequence && !canApplyLowerSequence) return;
-			internal.applyClientState(parseFullSyncState$1(latest.state));
-			internal.sequence = latest.sequence;
-			awaitingReconnectSync = false;
-			reconnectSequenceBaseline = null;
-		})().finally(() => {
-			syncingPromise = null;
-		});
-		return syncingPromise;
-	};
-	if (typeof transport.onConnect !== "function") throw new Error("transport.onConnect is required");
-	transport.onConnect?.(() => {
-		awaitingReconnectSync = true;
-		reconnectSequenceBaseline = internal.sequence;
-		fullSync(true).catch((error) => {
-			if (process.env.NODE_ENV === "development") console.error(error);
-		});
+	const isSharedWorker = typeof SharedWorker !== "undefined" && options.worker instanceof SharedWorker;
+	let transport;
+	try {
+		transport = options.worker ? 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);
 	});
-	transport.listen("update", async (options) => {
-		let shouldFullSync = false;
-		let allowLowerSequence = false;
+	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 {
-			if (typeof options.sequence !== "number") shouldFullSync = true;
-			else if (options.sequence <= internal.sequence) if (awaitingReconnectSync) {
-				shouldFullSync = true;
-				allowLowerSequence = true;
-			} else if (options.sequence === 0 && internal.sequence > 0) {
-				awaitingReconnectSync = true;
-				reconnectSequenceBaseline = internal.sequence;
-				shouldFullSync = true;
-				allowLowerSequence = true;
-			} else return;
-			else if (options.sequence === internal.sequence + 1) {
-				internal.applyClientState(void 0, options.patches);
-				internal.sequence = options.sequence;
-				awaitingReconnectSync = false;
-				reconnectSequenceBaseline = null;
-				return;
-			} else {
-				shouldFullSync = true;
-				allowLowerSequence = awaitingReconnectSync;
-			}
-			if (shouldFullSync) await fullSync(allowLowerSequence);
+			internal.applyClientState(state);
 		} catch (error) {
-			if (!shouldFullSync) try {
-				await fullSync(awaitingReconnectSync);
-			} catch (syncError) {
-				if (process.env.NODE_ENV === "development") console.error(syncError);
-			}
-			if (process.env.NODE_ENV === "development") console.error(error);
+			internal.transportEpoch = previousEpoch;
+			internal.sequence = previousSequence;
+			throw error;
 		}
-	});
-	return wrapStore(asyncClientStore, () => asyncClientStore.getState());
+	};
+	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) => {
-	const safePatches = sanitizePatches(patches);
-	if (store.transport && safePatches?.length) {
-		validateSharedStateSerializable(internal.rootState);
-		internal.sequence += 1;
-		store.transport.emit({
+	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
-		}, {
-			patches: safePatches,
-			sequence: internal.sequence
-		});
-	}
-};
-const handleDraft = (store, internal) => {
-	internal.rootState = internal.backupState;
-	const [nextState, patches, inversePatches] = internal.finalizeDraft();
-	if (store.share === "main") validateSharedStateSerializable(nextState);
-	const safePatches = sanitizePatches((store.patch ? store.patch({
-		patches,
-		inversePatches
-	}) : {
-		patches,
-		inversePatches
-	}).patches) ?? [];
-	if (safePatches.length) {
-		store.apply(internal.rootState, safePatches);
-		emit(store, internal, safePatches);
+		}, encoded);
+		Promise.resolve(pending).catch(reportLifecycleError);
+	} catch (error) {
+		reportLifecycleError(error);
 	}
 };
 //#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;
-	}, {});
+//#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
-const transportErrorMarker$1 = "__coactionTransportError__";
-const parseFullSyncState = (state) => {
-	const parsed = JSON.parse(state);
-	if (typeof parsed !== "object" || parsed === null) throw new Error("Invalid fullSync payload");
-	return sanitizeReplacementState(parsed);
-};
-const isTransportErrorEnvelope = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return value[transportErrorMarker$1] === true && typeof value.message === "string";
-};
-const isLegacyTransportErrorEnvelope = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return typeof candidate.$$Error === "string" && candidate.$$Error.length > 0 && Object.keys(candidate).length === 1;
+/**
+* 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) {
@@ -515,58 +912,237 @@ const createClientAction = ({ clientExecuteSyncTimeoutMs, internal, key, store,
 			}
 		};
 		if (typeof sliceKey === "symbol") throw new Error("Symbol-keyed slice actions are not supported in client store mode.");
-		const keys = typeof sliceKey !== "undefined" ? [String(sliceKey), key] : [key];
-		return traceAction(() => store.transport.emit("execute", keys, args).then(async (response) => {
-			const result = Array.isArray(response) ? response[0] : response;
-			const sequence = Array.isArray(response) ? typeof response[1] === "number" ? response[1] : internal.sequence : internal.sequence;
-			if (internal.sequence < sequence) {
-				if (process.env.NODE_ENV === "development") console.warn(`The sequence of the action is not consistent.`, sequence, internal.sequence);
-				await new Promise((resolve, reject) => {
-					let settled = false;
-					let unsubscribe = () => {};
-					const timeoutRef = {};
-					const cleanup = () => {
-						unsubscribe();
-						if (typeof timeoutRef.current !== "undefined") clearTimeout(timeoutRef.current);
-					};
-					const finishResolve = () => {
-						if (settled) return;
-						settled = true;
-						cleanup();
-						resolve();
-					};
-					const finishReject = (error) => {
-						if (settled) return;
-						settled = true;
-						cleanup();
-						reject(error);
-					};
-					unsubscribe = store.subscribe(() => {
-						if (internal.sequence >= sequence) finishResolve();
-					});
-					timeoutRef.current = setTimeout(() => {
-						store.transport.emit("fullSync").then((latest) => {
-							if (typeof latest !== "object" || latest === null) throw new Error("Invalid fullSync payload");
-							const next = latest;
-							if (typeof next.state !== "string" || typeof next.sequence !== "number") throw new Error("Invalid fullSync payload");
-							if (next.sequence >= sequence) {
-								(internal.applyClientState ?? store.apply.bind(store))(parseFullSyncState(next.state));
-								internal.sequence = next.sequence;
-								finishResolve();
-								return;
-							}
-							finishReject(/* @__PURE__ */ new Error(`Stale fullSync sequence: expected >= ${sequence}, got ${next.sequence}`));
-						}).catch((error) => {
-							finishReject(error);
+		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();
 						});
-					}, clientExecuteSyncTimeoutMs);
+						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" ? 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
 				});
 			}
-			if (isTransportErrorEnvelope(result)) throw new Error(result.message);
-			if (isLegacyTransportErrorEnvelope(result)) throw new Error(result.$$Error);
-			return result;
 		}));
+		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
@@ -575,6 +1151,7 @@ const getActionTarget = (store, sliceKey) => {
 };
 const createLocalAction = ({ fn, internal, key, options, store, sliceKey }) => {
 	return (...args) => {
+		internal.assertAlive?.(`action ${String(key)}`);
 		let actionId;
 		let done;
 		if (store.trace) {
@@ -650,85 +1227,139 @@ const createLocalAction = ({ fn, internal, key, options, store, sliceKey }) => {
 				return fn.apply(getActionTarget(store, sliceKey), args);
 			});
 			return fn.apply(getActionTarget(store, sliceKey), args);
-		});
-	};
-};
-//#endregion
-//#region packages/core/src/computed.ts
-const isObjectLike = (value) => typeof value === "object" && value !== null;
-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(() => evaluate(receiver));
-				memoByReceiver.set(receiver, accessor);
-			}
-			return accessor();
-		};
+		});
+	};
+};
+//#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 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(() => getter.call(receiver));
-			accessors.set(receiver, accessor);
+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);
 		}
-		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);
+	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);
 		}
-	} });
-	return () => {
-		const currentValue = slotSignal();
-		if (internal.mutableInstance && isObjectLike(currentValue)) slotVersionSignal();
-		return read();
-	};
+		for (let index = ancestors.length - 1; index >= 0; index -= 1) if (!Object.isFrozen(ancestors[index])) Object.freeze(ancestors[index]);
+	}
 };
-const refreshSignalSlots = (internal) => {
-	if (!internal.signalSlots?.size) return;
-	startBatch$1();
-	try {
-		internal.signalSlots.forEach((slot) => slot.refresh());
-	} finally {
-		endBatch$1();
+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];
@@ -749,37 +1380,49 @@ const prepareStateDescriptor = ({ descriptor, initialStateSeen, internal, key, r
 	});
 	if (isComputed) {
 		if (internal.mutableInstance) throw new Error("Computed is not supported with mutable instance");
-		descriptor.get = descriptor.value.createGetter({ internal });
+		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 = () => read();
+		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 = () => read();
+		descriptor.get = () => toReadonlyStateValue(internal, read());
 		descriptor.set = (value) => {
+			assertImmutableStateMutationAllowed(internal);
 			internal.rootState[key] = value;
 		};
 	}
 	delete descriptor.value;
 	delete descriptor.writable;
 };
-const prepareAccessorDescriptor = ({ descriptor, internal }) => {
+const prepareAccessorDescriptor = ({ descriptor, internal, sliceKey }) => {
 	if (internal.mutableInstance || typeof descriptor.get !== "function") return;
-	descriptor.get = createCachedGetter(internal, descriptor.get);
+	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) => {
+const getRawState = (store, internal, initialState, options, createClientAction) => {
 	const clientExecuteSyncTimeoutMs = getClientExecuteSyncTimeoutMs(options);
 	const rawState = {};
 	const handle = (_rawState, _initialState, sliceKey) => {
@@ -798,7 +1441,8 @@ const getRawState = (store, internal, initialState, options) => {
 			if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) {
 				prepareAccessorDescriptor({
 					descriptor,
-					internal
+					internal,
+					sliceKey
 				});
 				return;
 			}
@@ -816,6 +1460,7 @@ const getRawState = (store, internal, initialState, options) => {
 				}
 				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,
@@ -833,7 +1478,7 @@ const getRawState = (store, internal, initialState, options) => {
 				});
 			}
 		});
-		return Object.defineProperties({}, safeDescriptors);
+		return lockPublicStateObject(Object.defineProperties({}, safeDescriptors));
 	};
 	if (store.isSliceStore) {
 		internal.module = {};
@@ -843,19 +1488,27 @@ const getRawState = (store, internal, initialState, options) => {
 			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) => {
-	const setState = (next, updater = (next) => {
+	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) throw new Error("setState with async function is not supported");
+			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) {
@@ -863,9 +1516,11 @@ const handleState = (store, internal, options) => {
 				internal.actMutable(() => {
 					fn.apply(null);
 				});
+				defaultResultValidated = true;
 				return [];
 			}
 			fn.apply(null);
+			defaultResultValidated = true;
 			return [];
 		}
 		internal.backupState = internal.rootState;
@@ -876,42 +1531,71 @@ const handleState = (store, internal, options) => {
 				internal.rootState = draft;
 				return fn.apply(null);
 			}, { enablePatches: true });
-			if (store.share === "main") validateSharedStateSerializable(result[0]);
+			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 finalPatches = store.patch ? store.patch({
+		const patch = store.patch;
+		const finalPatches = patch ? patch({
 			patches,
 			inversePatches
 		}) : {
 			patches,
 			inversePatches
 		};
-		const safePatches = sanitizePatches(finalPatches.patches) ?? [];
-		const safeInversePatches = sanitizePatches(finalPatches.inversePatches) ?? [];
-		if (safePatches.length) store.apply(internal.rootState, safePatches);
+		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) try {
+		if (!store.share && !options.enablePatches && !internal.mutableInstance && updater === defaultUpdater) try {
 			if (typeof next === "function") try {
 				internal.backupState = internal.rootState;
-				internal.rootState = create$1(internal.rootState, (draft) => {
+				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$1(internal.rootState, (draft) => {
 					internal.rootState = draft;
 					const returnValue = next(internal.module);
-					if (returnValue instanceof Promise) throw new Error("setState with async function is not supported");
-					if (typeof returnValue === "object" && returnValue !== null) mergeObject(internal.rootState, returnValue, store.isSliceStore);
-				});
+					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;
@@ -932,6 +1616,7 @@ const handleState = (store, internal, options) => {
 						setOwnEnumerable(copyRecord, key, sliceCopy);
 					}
 				} else mergeObject(copy, next);
+				assertKnownStateShape(copy, internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
 				internal.rootState = copy;
 			}
 			refreshSignalSlots(internal);
@@ -946,7 +1631,8 @@ const handleState = (store, internal, options) => {
 			const isDrafted = internal.mutableInstance && isDraft(internal.rootState);
 			if (isDrafted) handleDraft(store, internal);
 			result = updater(next);
-			if (store.share === "main") validateSharedStateSerializable(internal.rootState);
+			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$1(internal.rootState, { enablePatches: true });
@@ -956,12 +1642,16 @@ const handleState = (store, internal, options) => {
 		} finally {
 			internal.isBatching = false;
 		}
-		if (result?.length) result = [
-			result[0],
-			sanitizePatches(result[1]) ?? [],
-			sanitizePatches(result[2]) ?? []
-		];
-		emit(store, internal, result?.[1]);
+		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;
@@ -971,95 +1661,183 @@ const handleState = (store, internal, options) => {
 	};
 };
 //#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/handleMainTransport.ts
-const getErrorMessage = (error) => {
-	if (error instanceof Error) return error.message;
-	return String(error);
+//#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 transportErrorMarker = "__coactionTransportError__";
-const handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
-	const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? createTransport(workerType, { prefix: store.name }) : void 0);
-	if (!transport) return;
-	if (typeof transport.onConnect !== "function") throw new Error("transport.onConnect is required");
-	if (checkEnablePatches) throw new Error(`enablePatches: true is required for the transport`);
-	transport.listen("execute", async (keys, args) => {
-		let base = store.getState();
-		try {
-			for (const key of keys) {
-				if (isUnsafePathSegment(key) || typeof base !== "object" && typeof base !== "function" || base === null || !Object.prototype.hasOwnProperty.call(base, key)) throw new Error("The function is not found");
-				const obj = base;
-				base = base[key];
-				if (typeof base === "function") base = base.bind(obj);
+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;
 			}
-			if (typeof base !== "function") throw new Error("The function is not found");
-			return [await base(...args), internal.sequence];
-		} catch (error) {
-			if (process.env.NODE_ENV === "development") console.error(error);
-			return [{
-				[transportErrorMarker]: true,
-				message: getErrorMessage(error)
-			}, internal.sequence];
+			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;
+			};
 		}
-	});
-	transport.listen("fullSync", async () => {
-		validateSharedStateSerializable(internal.rootState);
+		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 {
-			state: JSON.stringify(internal.rootState),
-			sequence: internal.sequence
+			store,
+			internal
 		};
-	});
-	store.transport = transport;
-};
-//#endregion
-//#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);
+	} catch (error) {
+		try {
+			store.destroy?.();
+		} catch (destroyError) {
+			if (process.env.NODE_ENV === "development") console.error(destroyError);
+		}
+		releaseStoreName();
+		throw error;
 	}
-	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/create.ts
-const namespaceMap = /* @__PURE__ */ new Map();
-let hasWarnedAmbiguousFunctionMap = false;
 const isMainWorkerType = (workerType) => workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal";
 const isClientWorkerType = (workerType) => workerType === "SharedWorkerClient" || workerType === "WebWorkerClient";
 const validateCreateModeOptions = (options) => {
@@ -1073,290 +1851,50 @@ const validateCreateModeOptions = (options) => {
 	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.");
 };
-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(" "));
-};
 /**
 * Create a local store, the main side of a shared store, or a client mirror of
 * a shared store.
 *
 * @remarks
-* - Pass a {@link Slice} function for a single store.
-* - Pass an object of slice factories for a slices store.
-* - When an object input only contains functions, prefer explicit `sliceMode`
-*   to avoid ambiguous inference.
-* - When `clientTransport` or `worker` is provided, returned store methods
-*   become promise-returning methods because execution happens on the main
-*   shared store.
-* - New semantics should prefer explicit helpers or variants over adding more
-*   ambiguous `create()` input forms.
+* 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 = workerType === "WebWorkerInternal" || workerType === "SharedWorkerInternal" || storeTransport ? "main" : void 0;
-	const createStore = ({ share }) => {
-		const store = {};
-		const internal = {
-			sequence: 0,
-			isBatching: false,
-			listeners: /* @__PURE__ */ new Set()
-		};
-		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.listeners.add(listener);
-				return () => internal.listeners.delete(listener);
-			};
-			let isDestroyed = false;
-			const destroy = () => {
-				if (isDestroyed) return;
-				isDestroyed = true;
-				internal.listeners.clear();
-				store.transport?.dispose();
-				releaseStoreName();
-			};
-			const apply$1 = (state = internal.rootState, patches) => {
-				internal.assertMutationAllowed?.("apply");
-				const safePatches = sanitizePatches(patches);
-				const nextState = sanitizeReplacementState(safePatches ? apply(state, safePatches) : state);
-				if (store.share === "main") validateSharedStateSerializable(nextState);
-				internal.rootState = nextState;
-				refreshSignalSlots(internal);
-				if (internal.updateImmutable) internal.updateImmutable(internal.rootState);
-				else internal.listeners.forEach((listener) => listener());
-			};
-			const getPureState = () => internal.rootState;
-			const isFunctionMapObject = () => {
-				if (typeof createState === "object" && createState !== null) {
-					const values = getOwnEnumerableKeys(createState).map((key) => createState[key]);
-					return values.length > 0 && values.every((value) => typeof value === "function");
-				}
-				return false;
-			};
-			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);
-			const initialState = getInitialState(store, createState, internal);
-			if (share) validateSharedActionPaths(initialState);
-			store.getInitialState = () => initialState;
-			internal.rootState = getRawState(store, internal, initialState, options);
-			if (share) validateSharedStateSerializable(internal.rootState);
-			markStoreReady(store);
-			return {
-				store,
-				internal
-			};
-		} catch (error) {
-			releaseStoreName();
-			throw error;
-		}
-	};
-	if (options.clientTransport || options.worker || options.workerType === "WebWorkerClient" || options.workerType === "SharedWorkerClient") {
-		if (checkEnablePatches) throw new Error(`enablePatches: true is required for the async store`);
-		return wrapStore(createAsyncClientStore(createStore, options));
-	}
-	const { store, internal } = createStore({ share });
-	handleMainTransport(store, internal, storeTransport, workerType, checkEnablePatches);
-	return wrapStore(store);
-};
-//#endregion
-//#region packages/core/src/binder.ts
-const createExternalStoreAdapter = ({ handleState, handleStore }) => ((state) => {
-	const { copyState, key, bind } = handleState(state);
-	const value = typeof key !== "undefined" ? copyState[key] : copyState;
-	Object.defineProperty(value, bindSymbol, {
-		configurable: true,
-		enumerable: typeof key !== "undefined",
-		value: {
-			handleStore,
-			bind
-		}
-	});
-	return copyState;
-});
-/**
-* Build an adapter helper for bridging an external store implementation into
-* Coaction.
-*
-* @remarks
-* Official bindings use this to integrate stores such as Redux, Jotai, Pinia,
-* Zustand, MobX, and Valtio. Binder-backed integrations are whole-store
-* adapters; they are not compatible with Coaction slices mode.
-*/
-function createBinder({ handleState, handleStore }) {
-	return createExternalStoreAdapter({
-		handleState,
-		handleStore
+	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
 	});
-}
-/**
-* Define a whole-store adapter for integrating an external state runtime with
-* Coaction.
-*
-* @remarks
-* This is the stable 2.x name for adapter authors. `createBinder()` remains as
-* a compatibility alias for existing official and community integrations.
-*/
-function defineExternalStoreAdapter(options) {
-	return createExternalStoreAdapter(options);
-}
-//#endregion
-//#region packages/core/src/reactiveTracker.ts
-const ReactiveFlags = alienSignalsSystem.ReactiveFlags;
-const unwatch = (node) => {
-	if (!(node.flags & ReactiveFlags.Mutable)) {
-		node.depsTail = void 0;
-		node.flags = 0;
-		purgeDeps(node);
-		const sub = node.subs;
-		if (sub !== void 0) unlink(sub);
-		return;
+	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 (node.depsTail !== void 0) {
-		node.depsTail = void 0;
-		node.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-		purgeDeps(node);
+	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 unlink = (link, sub = link.sub) => {
-	const dep = link.dep;
-	const prevDep = link.prevDep;
-	const nextDep = link.nextDep;
-	const nextSub = link.nextSub;
-	const prevSub = link.prevSub;
-	if (nextDep !== void 0) nextDep.prevDep = prevDep;
-	else sub.depsTail = prevDep;
-	if (prevDep !== void 0) prevDep.nextDep = nextDep;
-	else sub.deps = nextDep;
-	if (nextSub !== void 0) nextSub.prevSub = prevSub;
-	else dep.subsTail = prevSub;
-	if (prevSub !== void 0) prevSub.nextSub = nextSub;
-	else if ((dep.subs = nextSub) === void 0) unwatch(dep);
-	return nextDep;
-};
-const purgeDeps = (sub) => {
-	const depsTail = sub.depsTail;
-	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
-	while (dep !== void 0) dep = unlink(dep, sub);
-};
-const createReactiveTracker = () => {
-	let version = 0;
-	let disposed = false;
-	const listeners = /* @__PURE__ */ new Set();
-	const node = {
-		deps: void 0,
-		depsTail: void 0,
-		subs: void 0,
-		subsTail: void 0,
-		flags: ReactiveFlags.Watching,
-		fn: () => {
-			if (disposed) return;
-			version += 1;
-			listeners.forEach((listener) => listener());
-		}
-	};
-	const dispose = () => {
-		if (disposed) return;
-		disposed = true;
-		listeners.clear();
-		node.depsTail = void 0;
-		purgeDeps(node);
-		node.flags = 0;
-	};
-	return {
-		getSnapshot: () => version,
-		subscribe(listener) {
-			if (disposed) return () => void 0;
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		track(fn) {
-			if (disposed) return fn();
-			node.depsTail = void 0;
-			node.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-			const prevSub = setActiveSub(node);
-			try {
-				return fn();
-			} finally {
-				setActiveSub(prevSub);
-				node.flags &= ~ReactiveFlags.RecursedCheck;
-				purgeDeps(node);
-			}
-		},
-		dispose
-	};
-};
-//#endregion
-//#region packages/core/src/replaceExternalStoreState.ts
-const replaceExternalStoreState = (store, internal, source, { syncImmutable = true } = {}) => {
-	const [, patches, inversePatches] = create$1(internal.rootState, (draft) => {
-		replaceOwnEnumerable(draft, source);
-	}, { enablePatches: true });
-	const safePatches = sanitizePatches((store.patch ? store.patch({
-		patches,
-		inversePatches
-	}) : {
-		patches,
-		inversePatches
-	}).patches) ?? [];
-	if (!safePatches.length) return;
-	const updateImmutable = internal.updateImmutable;
-	if (!syncImmutable) internal.updateImmutable = void 0;
+	const { store, internal } = builtStore;
 	try {
-		store.apply(internal.rootState, safePatches);
-	} finally {
-		internal.updateImmutable = updateImmutable;
+		handleMainTransport(store, internal, storeTransport, workerType, checkEnablePatches, options.transportPolicy);
+		markStoreReady(store);
+		internal.assertAlive?.("store initialization");
+	} catch (error) {
+		return failStoreSetup(store, error);
 	}
-	emit(store, internal, safePatches);
+	return wrapStore(store);
 };
 //#endregion
-export { computed, create, createBinder, createReactiveTracker, defineExternalStoreAdapter, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, onStoreReady, replaceExternalStoreState, replaceOwnEnumerable, sanitizeInitialStateValue, sanitizeReplacementState, signal, startBatch, trigger, wrapStore };
+export { ActionAuthorityChangedError, StateSchemaError, UnsafePatchPathError, assertSafePatches, computed, create, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, isStateSchemaError, onStoreReady, sanitizeInitialStateValue, sanitizePatches, sanitizeReplacementState, signal, startBatch, trigger };