coaction 2.0.0 → 2.1.0

package/dist/index.mjs

@@ -38,13 +38,129 @@ 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 createRootReplacementPatches = (currentState, nextState) => {
+	const patches = [];
+	const inversePatches = [];
+	const nextKeys = new Set(getOwnEnumerableKeys(nextState));
+	for (const key of getOwnEnumerableKeys(currentState)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		if (nextKeys.has(key)) continue;
+		patches.push({
+			op: "remove",
+			path: [key]
+		});
+		inversePatches.push({
+			op: "add",
+			path: [key],
+			value: currentState[key]
+		});
+	}
+	for (const key of nextKeys) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		if (!Object.prototype.hasOwnProperty.call(currentState, key)) {
+			patches.push({
+				op: "add",
+				path: [key],
+				value: nextState[key]
+			});
+			inversePatches.push({
+				op: "remove",
+				path: [key]
+			});
+			continue;
+		}
+		if (Object.is(currentState[key], nextState[key])) continue;
+		patches.push({
+			op: "replace",
+			path: [key],
+			value: nextState[key]
+		});
+		inversePatches.push({
+			op: "replace",
+			path: [key],
+			value: currentState[key]
+		});
+	}
+	return {
+		patches,
+		inversePatches
+	};
+};
+const createRootStateFromPatches = (currentState, patches) => {
+	const nextState = sanitizeReplacementState(currentState);
+	const seen = /* @__PURE__ */ new WeakMap();
+	for (const patch of patches) {
+		if (!Array.isArray(patch.path) || patch.path.length !== 1 || ![
+			"add",
+			"remove",
+			"replace"
+		].includes(patch.op)) return;
+		const key = patch.path[0];
+		if (patch.op === "remove") {
+			delete nextState[key];
+			continue;
+		}
+		nextState[key] = sanitizeReplacementState(patch.value, seen);
+	}
+	return nextState;
+};
+const applyRootReplacementWithPatches = (store, nextState, options = {}) => {
+	const { patches, inversePatches } = createRootReplacementPatches(store.getPureState(), nextState);
+	const finalPatches = store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	};
+	const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+	const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
+	if (safePatches.length) {
+		const applyExactReplacement = options.applyExactReplacement;
+		const exactReplacementState = applyExactReplacement ? createRootStateFromPatches(store.getPureState(), safePatches) : void 0;
+		if (applyExactReplacement && exactReplacementState) applyExactReplacement(exactReplacementState);
+		else store.apply(store.getPureState(), safePatches);
+	}
+	return [
+		store.getPureState(),
+		safePatches,
+		safeInversePatches
+	];
+};
 const setOwnEnumerable = (target, key, value) => {
 	if (typeof key === "string" && isUnsafeKey(key)) return;
 	target[key] = value;
@@ -53,7 +169,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$2 = (key) => {
 	if (typeof key !== "string") return false;
 	const index = Number(key);
 	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
@@ -91,7 +259,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$2(key) || typeof key === "string" && isUnsafeKey(key)) continue;
 			const value = source[key];
 			if (typeof value === "function") continue;
 			setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
@@ -120,7 +288,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$2(key) || typeof key === "string" && isUnsafeKey(key)) continue;
 			setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
 		}
 		return target;
@@ -171,7 +339,7 @@ const isPlainObject = (value) => {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === Object.prototype || prototype === null;
 };
-const isArrayIndexKey = (key, length) => {
+const isArrayIndexKey$1 = (key, length) => {
 	if (key === "") return false;
 	const index = Number(key);
 	return Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
@@ -235,7 +403,7 @@ const findJsonViolation = (value, path = [], ancestors = /* @__PURE__ */ new Wea
 				type: "symbol-key",
 				path: nextPath
 			};
-			if (!isArrayIndexKey(key, value.length)) return {
+			if (!isArrayIndexKey$1(key, value.length)) return {
 				type: "array-property",
 				path: nextPath
 			};
@@ -369,6 +537,7 @@ const createAsyncClientStore = (createStore, asyncStoreClientOption) => {
 				allowLowerSequence = true;
 			} else return;
 			else if (options.sequence === internal.sequence + 1) {
+				assertSafePatches(options.patches, "client transport update");
 				internal.applyClientState(void 0, options.patches);
 				internal.sequence = options.sequence;
 				awaitingReconnectSync = false;
@@ -391,7 +560,10 @@ const createAsyncClientStore = (createStore, asyncStoreClientOption) => {
 	return wrapStore(asyncClientStore, () => asyncClientStore.getState());
 };
 const emit = (store, internal, patches) => {
-	const safePatches = sanitizePatches(patches);
+	const safePatches = sanitizePatches(patches, {
+		source: "transport emit",
+		warnOnDropped: true
+	});
 	if (store.transport && safePatches?.length) {
 		validateSharedStateSerializable(internal.rootState);
 		internal.sequence += 1;
@@ -408,13 +580,13 @@ 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({
+	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
 		patches,
 		inversePatches
 	}) : {
 		patches,
 		inversePatches
-	}).patches) ?? [];
+	}).patches, "store.patch()");
 	if (safePatches.length) {
 		store.apply(internal.rootState, safePatches);
 		emit(store, internal, safePatches);
@@ -478,6 +650,7 @@ const isLegacyTransportErrorEnvelope = (value) => {
 };
 const createClientAction = ({ clientExecuteSyncTimeoutMs, internal, key, store, sliceKey }) => {
 	return (...args) => {
+		internal.assertAlive?.(`action ${key}`);
 		let actionId;
 		let done;
 		if (store.trace) {
@@ -575,6 +748,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) {
@@ -729,6 +903,63 @@ const refreshSignalSlots = (internal) => {
 };
 //#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 isReadonlyProxyable = (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 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 || !isReadonlyProxyable(value)) return value;
+	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 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];
@@ -752,14 +983,16 @@ const prepareStateDescriptor = ({ descriptor, initialStateSeen, internal, key, r
 		descriptor.get = descriptor.value.createGetter({ internal });
 	} 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;
 		};
 	}
@@ -773,6 +1006,10 @@ const prepareAccessorDescriptor = ({ descriptor, internal }) => {
 //#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;
@@ -833,7 +1070,7 @@ const getRawState = (store, internal, initialState, options) => {
 				});
 			}
 		});
-		return Object.defineProperties({}, safeDescriptors);
+		return lockPublicStateObject(Object.defineProperties({}, safeDescriptors));
 	};
 	if (store.isSliceStore) {
 		internal.module = {};
@@ -843,19 +1080,24 @@ 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) => {
+	const defaultUpdater = (next) => {
 		const merge = (_next = 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) {
@@ -876,6 +1118,7 @@ const handleState = (store, internal, options) => {
 				internal.rootState = draft;
 				return fn.apply(null);
 			}, { enablePatches: true });
+			assertKnownStateShape(result[0], internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
 			if (store.share === "main") validateSharedStateSerializable(result[0]);
 			patches = result[1];
 			inversePatches = result[2];
@@ -889,29 +1132,40 @@ const handleState = (store, internal, options) => {
 			patches,
 			inversePatches
 		};
-		const safePatches = sanitizePatches(finalPatches.patches) ?? [];
-		const safeInversePatches = sanitizePatches(finalPatches.inversePatches) ?? [];
+		const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+		const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
 		if (safePatches.length) store.apply(internal.rootState, safePatches);
 		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") 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 nextState = 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);
+					}
 				});
+				assertKnownStateShape(nextState, internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				internal.rootState = nextState;
 			} catch (error) {
 				internal.rootState = internal.backupState;
 				throw error;
@@ -932,6 +1186,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,6 +1201,7 @@ const handleState = (store, internal, options) => {
 			const isDrafted = internal.mutableInstance && isDraft(internal.rootState);
 			if (isDrafted) handleDraft(store, internal);
 			result = updater(next);
+			if (internal.mutableInstance) assertKnownStateShape(internal.rootState, internal.backupState ?? internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
 			if (store.share === "main") validateSharedStateSerializable(internal.rootState);
 			if (isDrafted) {
 				internal.backupState = internal.rootState;
@@ -958,8 +1214,8 @@ const handleState = (store, internal, options) => {
 		}
 		if (result?.length) result = [
 			result[0],
-			sanitizePatches(result[1]) ?? [],
-			sanitizePatches(result[2]) ?? []
+			sanitizeCheckedPatches(result[1], "setState updater result"),
+			sanitizeCheckedPatches(result[2], "setState updater inverse result")
 		];
 		emit(store, internal, result?.[1]);
 		return result;
@@ -1127,10 +1383,14 @@ const create = (createState, options = {}) => {
 		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;
@@ -1139,9 +1399,13 @@ const create = (createState, options = {}) => {
 				releaseStoreName();
 			};
 			const apply$1 = (state = internal.rootState, patches) => {
+				internal.assertAlive?.("apply");
 				internal.assertMutationAllowed?.("apply");
+				assertSafePatches(patches, "store.apply()");
 				const safePatches = sanitizePatches(patches);
-				const nextState = sanitizeReplacementState(safePatches ? apply(state, safePatches) : state);
+				const baseState = state === internal.module ? internal.rootState : state;
+				const nextState = sanitizeReplacementState(safePatches ? apply(baseState, safePatches) : baseState);
+				assertKnownStateShape(nextState, internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
 				if (store.share === "main") validateSharedStateSerializable(nextState);
 				internal.rootState = nextState;
 				refreshSignalSlots(internal);
@@ -1187,6 +1451,7 @@ const create = (createState, options = {}) => {
 			if (share) validateSharedActionPaths(initialState);
 			store.getInitialState = () => initialState;
 			internal.rootState = getRawState(store, internal, initialState, options);
+			internal.stateSchema = createStateSchema(internal.rootState, store.isSliceStore);
 			if (share) validateSharedStateSerializable(internal.rootState);
 			markStoreReady(store);
 			return {
@@ -1341,13 +1606,13 @@ const replaceExternalStoreState = (store, internal, source, { syncImmutable = tr
 	const [, patches, inversePatches] = create$1(internal.rootState, (draft) => {
 		replaceOwnEnumerable(draft, source);
 	}, { enablePatches: true });
-	const safePatches = sanitizePatches((store.patch ? store.patch({
+	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
 		patches,
 		inversePatches
 	}) : {
 		patches,
 		inversePatches
-	}).patches) ?? [];
+	}).patches, "store.patch()");
 	if (!safePatches.length) return;
 	const updateImmutable = internal.updateImmutable;
 	if (!syncImmutable) internal.updateImmutable = void 0;
@@ -1359,4 +1624,129 @@ const replaceExternalStoreState = (store, internal, source, { syncImmutable = tr
 	emit(store, internal, safePatches);
 };
 //#endregion
-export { computed, create, createBinder, createReactiveTracker, defineExternalStoreAdapter, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, onStoreReady, replaceExternalStoreState, replaceOwnEnumerable, sanitizeInitialStateValue, sanitizeReplacementState, signal, startBatch, trigger, wrapStore };
+//#region packages/core/src/externalMutableAdapterUtils.ts
+const getMutableAdapterOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isMutableAdapterUnsafeKey = (key) => typeof key === "string" && isUnsafeKey(key);
+const isArrayIndexKey = (key) => {
+	if (typeof key !== "string") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+};
+const isObjectRecord = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const assertCanSetMutableAdapterPublicStateKey = (publicState, key) => {
+	if (Object.prototype.hasOwnProperty.call(publicState, key)) return;
+	if (Object.isExtensible(publicState)) return;
+	throw new StateSchemaError(`Unknown state key '${String(key)}' cannot be added after store initialization. Coaction state schema is fixed.`);
+};
+const ensureMutableAdapterRawDescriptor = (rawState, mutableState, publicState, key) => {
+	if (rawState === mutableState) return;
+	const rawDescriptor = Object.getOwnPropertyDescriptor(rawState, key);
+	if (rawDescriptor?.get && rawDescriptor.set) return;
+	const publicDescriptor = Object.getOwnPropertyDescriptor(publicState, key);
+	if (!publicDescriptor || rawDescriptor?.configurable === false) return;
+	Object.defineProperty(rawState, key, {
+		get: () => mutableState[key],
+		set: (value) => {
+			mutableState[key] = value;
+		},
+		configurable: true,
+		enumerable: publicDescriptor.enumerable
+	});
+};
+const replaceMutableAdapterState = (rawState, mutableState, publicState, source) => {
+	const nextKeys = /* @__PURE__ */ new Set();
+	for (const key of getMutableAdapterOwnEnumerableKeys(source)) {
+		if (isMutableAdapterUnsafeKey(key)) continue;
+		if (typeof source[key] === "function") continue;
+		nextKeys.add(key);
+	}
+	nextKeys.forEach((key) => {
+		assertCanSetMutableAdapterPublicStateKey(publicState, key);
+	});
+	for (const key of getMutableAdapterOwnEnumerableKeys(rawState)) {
+		if (isMutableAdapterUnsafeKey(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			continue;
+		}
+		if (typeof rawState[key] === "function") continue;
+		if (!nextKeys.has(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+		}
+	}
+	const rawSeen = /* @__PURE__ */ new WeakMap();
+	const mutableSeen = /* @__PURE__ */ new WeakMap();
+	const publicSeen = /* @__PURE__ */ new WeakMap();
+	rawSeen.set(source, rawState);
+	mutableSeen.set(source, mutableState);
+	publicSeen.set(source, publicState);
+	nextKeys.forEach((key) => {
+		ensureMutableAdapterRawDescriptor(rawState, mutableState, publicState, key);
+		rawState[key] = sanitizeReplacementState(source[key], rawSeen);
+		mutableState[key] = sanitizeReplacementState(source[key], mutableSeen);
+		publicState[key] = sanitizeReplacementState(source[key], publicSeen);
+	});
+};
+const applyMutableAdapterPatches = (baseState, patches, rawState, mutableState, publicState) => {
+	assertSafePatches(patches, "mutable adapter apply()");
+	replaceMutableAdapterState(rawState, mutableState, publicState, apply(toMutableAdapterSnapshot(baseState === publicState ? rawState : baseState), patches));
+};
+const toMutableAdapterSnapshot = (value, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Array.isArray(value)) {
+		if (visited.has(value)) return visited.get(value);
+		const next = [];
+		next.length = value.length;
+		visited.set(value, next);
+		for (let index = 0; index < value.length; index += 1) if (Object.prototype.hasOwnProperty.call(value, index)) next[index] = toMutableAdapterSnapshot(value[index], visited);
+		const source = value;
+		const target = next;
+		for (const key of getMutableAdapterOwnEnumerableKeys(value)) {
+			if (isArrayIndexKey(key) || isMutableAdapterUnsafeKey(key)) continue;
+			const child = source[key];
+			if (typeof child !== "function") target[key] = toMutableAdapterSnapshot(child, visited);
+		}
+		return next;
+	}
+	if (typeof value === "object" && value !== null) {
+		if (!isObjectRecord(value)) return value;
+		if (visited.has(value)) return visited.get(value);
+		const next = {};
+		visited.set(value, next);
+		for (const key of getMutableAdapterOwnEnumerableKeys(value)) {
+			if (isMutableAdapterUnsafeKey(key)) continue;
+			const child = value[key];
+			if (typeof child !== "function") next[key] = toMutableAdapterSnapshot(child, visited);
+		}
+		return next;
+	}
+	return value;
+};
+const snapshotMutableAdapterPureState = (store) => toMutableAdapterSnapshot(store.getPureState());
+const isEqualMutableAdapterSnapshot = (left, right, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	const leftIsArray = Array.isArray(left);
+	const rightIsArray = Array.isArray(right);
+	if (leftIsArray || rightIsArray) {
+		if (!leftIsArray || !rightIsArray || left.length !== right.length) return false;
+	} else if (!isObjectRecord(left) || !isObjectRecord(right)) return false;
+	let seenTargets = visited.get(left);
+	if (!seenTargets) {
+		seenTargets = /* @__PURE__ */ new WeakSet();
+		visited.set(left, seenTargets);
+	} else if (seenTargets.has(right)) return true;
+	seenTargets.add(right);
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = getMutableAdapterOwnEnumerableKeys(left);
+	const rightKeys = getMutableAdapterOwnEnumerableKeys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) return false;
+		if (!isEqualMutableAdapterSnapshot(leftRecord[key], rightRecord[key], visited)) return false;
+	}
+	return true;
+};
+//#endregion
+export { StateSchemaError, UnsafePatchPathError, applyMutableAdapterPatches, applyRootReplacementWithPatches, assertSafePatches, computed, create, createBinder, createReactiveTracker, createRootReplacementPatches, defineExternalStoreAdapter, effect, effectScope, endBatch, getMutableAdapterOwnEnumerableKeys, isComputed, isEffect, isEffectScope, isEqualMutableAdapterSnapshot, isMutableAdapterUnsafeKey, isSignal, isStateSchemaError, onStoreReady, replaceExternalStoreState, replaceMutableAdapterState, replaceOwnEnumerable, sanitizeInitialStateValue, sanitizePatches, sanitizeReplacementState, signal, snapshotMutableAdapterPureState, startBatch, toMutableAdapterSnapshot, trigger, wrapStore };