coaction 1.5.0 → 2.1.0

package/dist/index.js

@@ -1,1188 +1,1865 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  create: () => create,
-  createBinder: () => createBinder,
-  wrapStore: () => wrapStore
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/create.ts
-var import_mutative3 = require("mutative");
-
-// src/global.ts
-var getGlobal = () => {
-  let _global2;
-  if (typeof window !== "undefined") {
-    _global2 = window;
-  } else if (typeof global !== "undefined") {
-    _global2 = global;
-  } else if (typeof self !== "undefined") {
-    _global2 = self;
-  } else {
-    _global2 = {};
-  }
-  return _global2;
-};
-var _global = getGlobal();
-
-// src/constant.ts
-var WorkerType = _global.SharedWorkerGlobalScope ? "SharedWorkerInternal" : globalThis.WorkerGlobalScope ? "WebWorkerInternal" : null;
-var bindSymbol = /* @__PURE__ */ Symbol("bind");
-var defaultName = "default";
-
-// src/asyncClientStore.ts
-var import_data_transport = require("data-transport");
-
-// src/wrapStore.ts
-var wrapStore = (store, getState = () => store.getState()) => {
-  const { name, ..._store } = store;
-  return Object.assign(
-    {
-      [name]: (...args) => getState(...args)
-    }[name],
-    _store
-  );
-};
-
-// src/asyncClientStore.ts
-var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
-  const { store: asyncClientStore, internal } = createStore({
-    share: "client"
-  });
-  const transport = asyncStoreClientOption.worker ? (0, import_data_transport.createTransport)(
-    asyncStoreClientOption.worker instanceof SharedWorker ? "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.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;
-        }
-        asyncClientStore.apply(JSON.parse(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;
-    void fullSync(true).catch((error) => {
-      if (process.env.NODE_ENV === "development") {
-        console.error(error);
-      }
-    });
-  });
-  transport.listen("update", async (options) => {
-    let shouldFullSync = false;
-    let allowLowerSequence = false;
-    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) {
-        asyncClientStore.apply(void 0, options.patches);
-        internal.sequence = options.sequence;
-        awaitingReconnectSync = false;
-        reconnectSequenceBaseline = null;
-        return;
-      } else {
-        shouldFullSync = true;
-        allowLowerSequence = awaitingReconnectSync;
-      }
-      if (shouldFullSync) {
-        await fullSync(allowLowerSequence);
-      }
-    } 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);
-      }
-    }
-  });
-  return wrapStore(asyncClientStore, () => asyncClientStore.getState());
-};
-var emit = (store, internal, patches) => {
-  if (store.transport && patches?.length) {
-    internal.sequence += 1;
-    store.transport.emit(
-      {
-        name: "update",
-        respond: false
-      },
-      {
-        patches,
-        sequence: internal.sequence
-      }
-    );
-  }
-};
-var handleDraft = (store, internal) => {
-  internal.rootState = internal.backupState;
-  const [, patches, inversePatches] = internal.finalizeDraft();
-  const finalPatches = store.patch ? store.patch({ patches, inversePatches }) : { patches, inversePatches };
-  if (finalPatches.patches.length) {
-    store.apply(internal.rootState, finalPatches.patches);
-    emit(store, internal, finalPatches.patches);
-  }
-};
-
-// src/getInitialState.ts
-var isObject = (value) => typeof value === "object" && value !== null;
-var isStateFactory = (value) => typeof value === "function";
-var hasGetState = (value) => (typeof value === "object" || typeof value === "function") && value !== null && typeof value.getState === "function";
-var hasBindState = (value) => isObject(value) && !!value[bindSymbol];
-var formatInvalidStateMessage = (type, stateOrFn, key) => `Invalid state ${type} encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`;
-var 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;
-  };
-  return store.isSliceStore ? Object.entries(createState).reduce(
-    (stateTree, [key, value]) => Object.assign(stateTree, {
-      [key]: makeState(value, key)
-    }),
-    {}
-  ) : makeState(createState);
-};
-
-// src/utils.ts
-var isEqual = (x, y) => {
-  if (x === y) {
-    return x !== 0 || y !== 0 || 1 / x === 1 / y;
-  }
-  return x !== x && y !== y;
-};
-var isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
-var setOwnEnumerable = (target, key, value) => {
-  if (typeof key === "string" && isUnsafeKey(key)) {
-    return;
-  }
-  target[key] = value;
-};
-var assignOwnEnumerable = (target, source) => {
-  for (const key of Object.keys(source)) {
-    setOwnEnumerable(target, key, source[key]);
-  }
-};
-var cloneOwnEnumerable = (source) => {
-  const target = {};
-  assignOwnEnumerable(target, source);
-  return target;
-};
-var areShallowEqualWithArray = (prev, next) => {
-  if (prev === null || next === null || prev.length !== next.length) {
-    return false;
-  }
-  const { length } = prev;
-  for (let i = 0; i < length; i += 1) {
-    if (!isEqual(prev[i], next[i])) {
-      return false;
-    }
-  }
-  return true;
-};
-var mergeObject = (target, source, isSlice) => {
-  if (isSlice) {
-    if (typeof source === "object" && source !== null) {
-      for (const key of Object.keys(source)) {
-        if (isUnsafeKey(key)) {
-          continue;
-        }
-        if (!Object.prototype.hasOwnProperty.call(target, key)) {
-          continue;
-        }
-        const sourceValue = source[key];
-        if (typeof sourceValue !== "object" || sourceValue === null) {
-          continue;
-        }
-        const targetValue = target[key];
-        if (typeof targetValue === "object" && targetValue !== null) {
-          assignOwnEnumerable(targetValue, sourceValue);
-        }
-      }
-    }
-  } else {
-    if (typeof source === "object" && source !== null) {
-      assignOwnEnumerable(target, source);
-    }
-  }
-};
-var uuid = () => {
-  let timestamp = (/* @__PURE__ */ new Date()).getTime();
-  const uuidTemplate = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
-  const uuid2 = uuidTemplate.replace(/[xy]/g, (char) => {
-    const randomNum = (timestamp + Math.random() * 16) % 16 | 0;
-    timestamp = Math.floor(timestamp / 16);
-    return (char === "x" ? randomNum : randomNum & 3 | 8).toString(16);
-  });
-  return uuid2;
-};
-
-// src/getRawStateClientAction.ts
-var transportErrorMarker = "__coactionTransportError__";
-var isTransportErrorEnvelope = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  return value[transportErrorMarker] === true && typeof value.message === "string";
-};
-var 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;
-};
-var createClientAction = ({
-  clientExecuteSyncTimeoutMs,
-  internal,
-  key,
-  store,
-  sliceKey
-}) => {
-  return (...args) => {
-    let actionId;
-    let done;
-    if (store.trace) {
-      actionId = uuid();
-      store.trace({
-        method: key,
-        parameters: args,
-        id: actionId,
-        sliceKey
-      });
-      done = (result) => {
-        store.trace({
-          method: key,
-          id: actionId,
-          result,
-          sliceKey
-        });
-      };
-    }
-    const traceAction = (run) => {
-      try {
-        const result = run();
-        if (result instanceof Promise) {
-          return result.then(
-            (value) => {
-              done?.(value);
-              return value;
-            },
-            (error) => {
-              done?.(error);
-              throw error;
-            }
-          );
-        }
-        done?.(result);
-        return result;
-      } catch (error) {
-        done?.(error);
-        throw error;
-      }
-    };
-    const keys = sliceKey ? [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(() => {
-              void store.transport.emit("fullSync").then((latest) => {
-                const next = latest;
-                if (typeof next.state !== "string" || typeof next.sequence !== "number") {
-                  throw new Error("Invalid fullSync payload");
-                }
-                if (next.sequence >= sequence) {
-                  store.apply(JSON.parse(next.state));
-                  internal.sequence = next.sequence;
-                  finishResolve();
-                  return;
-                }
-                finishReject(
-                  new Error(
-                    `Stale fullSync sequence: expected >= ${sequence}, got ${next.sequence}`
-                  )
-                );
-              }).catch((error) => {
-                finishReject(error);
-              });
-            }, clientExecuteSyncTimeoutMs);
-          });
-        }
-        if (isTransportErrorEnvelope(result)) {
-          throw new Error(result.message);
-        }
-        if (isLegacyTransportErrorEnvelope(result)) {
-          throw new Error(result.$$Error);
-        }
-        return result;
-      })
-    );
-  };
-};
-
-// src/getRawStateLocalAction.ts
-var import_mutative = require("mutative");
-var getActionTarget = (store, sliceKey) => {
-  return sliceKey ? store.getState()[sliceKey] : store.getState();
-};
-var createLocalAction = ({
-  fn,
-  internal,
-  key,
-  options,
-  store,
-  sliceKey
-}) => {
-  return (...args) => {
-    let actionId;
-    let done;
-    if (store.trace) {
-      actionId = uuid();
-      store.trace({
-        method: key,
-        parameters: args,
-        id: actionId,
-        sliceKey
-      });
-      done = (result) => {
-        store.trace({
-          method: key,
-          id: actionId,
-          result,
-          sliceKey
-        });
-      };
-    }
-    const traceAction = (run) => {
-      try {
-        const result = run();
-        if (result instanceof Promise) {
-          return result.then(
-            (value) => {
-              done?.(value);
-              return value;
-            },
-            (error) => {
-              done?.(error);
-              throw error;
-            }
-          );
-        }
-        done?.(result);
-        return result;
-      } catch (error) {
-        done?.(error);
-        throw error;
-      }
-    };
-    const enablePatches = store.transport ?? options.enablePatches;
-    return traceAction(() => {
-      if (internal.mutableInstance && !internal.isBatching && enablePatches) {
-        let result;
-        const handleResult = (isDrafted2) => {
-          handleDraft(store, internal);
-          if (isDrafted2) {
-            internal.backupState = internal.rootState;
-            const [draft2, finalize2] = (0, import_mutative.create)(internal.rootState, {
-              enablePatches: true
-            });
-            internal.finalizeDraft = finalize2;
-            internal.rootState = draft2;
-          }
-        };
-        const isDrafted = (0, import_mutative.isDraft)(internal.rootState);
-        if (isDrafted) {
-          handleResult();
-        }
-        internal.backupState = internal.rootState;
-        const [draft, finalize] = (0, import_mutative.create)(internal.rootState, {
-          enablePatches: true
-        });
-        internal.finalizeDraft = finalize;
-        internal.rootState = draft;
-        let asyncResult;
-        try {
-          result = fn.apply(getActionTarget(store, sliceKey), args);
-          if (result instanceof Promise) {
-            asyncResult = result;
-          }
-        } finally {
-          if (!asyncResult) {
-            handleResult(isDrafted);
-          }
-        }
-        if (asyncResult) {
-          return asyncResult.then(
-            (value) => {
-              handleResult(isDrafted);
-              return value;
-            },
-            (error) => {
-              handleResult(isDrafted);
-              throw error;
-            }
-          );
-        }
-        return result;
-      }
-      if (internal.mutableInstance && internal.actMutable) {
-        return internal.actMutable(() => {
-          return fn.apply(getActionTarget(store, sliceKey), args);
-        });
-      }
-      return fn.apply(getActionTarget(store, sliceKey), args);
-    });
-  };
-};
-
-// src/computed.ts
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let mutative = require("mutative");
+let data_transport = require("data-transport");
+let alien_signals = require("alien-signals");
+let alien_signals_system = require("alien-signals/system");
+alien_signals_system = __toESM(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;
+};
+//#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);
+};
+//#endregion
+//#region packages/core/src/utils.ts
+const isEqual = (x, y) => {
+	if (x === y) return x !== 0 || y !== 0 || 1 / x === 1 / y;
+	return x !== x && y !== y;
+};
+const isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+const isUnsafePathSegment = (segment) => typeof segment === "string" && isUnsafeKey(segment);
+var UnsafePatchPathError = class extends Error {
+	name = "UnsafePatchPathError";
+};
+var StateSchemaError = class extends Error {
+	name = "StateSchemaError";
+};
+const isStateSchemaError = (error) => error instanceof StateSchemaError || error instanceof Error && error.name === "StateSchemaError";
+const hasUnsafePatchPath = (path) => {
+	return (Array.isArray(path) ? path : typeof path === "string" ? path.split("/").filter(Boolean).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")) : []).some(isUnsafePathSegment);
+};
+const formatPatchPath = (path) => Array.isArray(path) ? path.map((segment) => String(segment)).join(".") : String(path);
+const getUnsafePatchPaths = (patches) => patches?.filter((patch) => hasUnsafePatchPath(patch.path)) ?? [];
+const assertSafePatches = (patches, source = "patches") => {
+	const unsafePatches = getUnsafePatchPaths(patches);
+	if (!unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	throw new UnsafePatchPathError(`Unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} cannot be applied from ${source}.`);
+};
+const warnDroppedUnsafePatches = (unsafePatches, source) => {
+	if (process.env.NODE_ENV !== "development" || !unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	console.warn(`Coaction dropped unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} from ${source}.`);
+};
+const sanitizePatches = (patches, options = {}) => {
+	if (options.warnOnDropped) warnDroppedUnsafePatches(getUnsafePatchPaths(patches), options.source ?? "patches");
+	return patches?.filter((patch) => !hasUnsafePatchPath(patch.path)).map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
+		...patch,
+		value: sanitizeReplacementState(patch.value)
+	} : patch);
+};
+const sanitizeCheckedPatches = (patches, source) => {
+	assertSafePatches(patches, source);
+	return sanitizePatches(patches) ?? [];
+};
+const 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;
+};
+const getOwnEnumerableKeys = (source) => {
+	if (typeof source !== "object" || source === null) return [];
+	return Reflect.ownKeys(source).filter((key) => Object.prototype.propertyIsEnumerable.call(source, key));
+};
+const getOwnSchemaKeys = (source) => {
+	if (typeof source !== "object" || source === null) return [];
+	return Reflect.ownKeys(source).filter((key) => !(typeof key === "string" && isUnsafeKey(key)));
+};
+const formatSchemaPath = (path) => path.length ? path.map((key) => String(key)).join(".") : "<root>";
+const assertKnownSchemaKey = (knownKeys, key, path) => {
+	if (typeof key === "string" && isUnsafeKey(key)) return;
+	if (knownKeys.has(key)) return;
+	throw new StateSchemaError(`Unknown state key '${formatSchemaPath([...path, key])}' cannot be added after store initialization. Coaction state schema is fixed.`);
+};
+const assertKnownSliceObject = (key, value) => {
+	if (typeof value === "object" && value !== null) return;
+	throw new StateSchemaError(`State slice '${String(key)}' must remain an object after store initialization. Coaction slice schema is fixed.`);
+};
+const assertKnownSlicePresent = (source, key) => {
+	if (Object.prototype.hasOwnProperty.call(source, key)) return;
+	throw new StateSchemaError(`State slice '${String(key)}' cannot be removed after store initialization. Coaction slice schema is fixed.`);
+};
+const createStateSchema = (rootState, isSliceStore) => {
+	const rootKeys = new Set(getOwnSchemaKeys(rootState));
+	if (!isSliceStore) return { rootKeys };
+	const sliceKeys = /* @__PURE__ */ new Map();
+	if (typeof rootState === "object" && rootState !== null) {
+		const rootRecord = rootState;
+		rootKeys.forEach((key) => {
+			const slice = rootRecord[key];
+			if (typeof slice === "object" && slice !== null) sliceKeys.set(key, new Set(getOwnSchemaKeys(slice)));
+		});
+	}
+	return {
+		rootKeys,
+		sliceKeys
+	};
+};
+const assertKnownStateShape = (source, rootState, schema, isSliceStore, options = {}) => {
+	if (typeof source !== "object" || source === null) return;
+	const rootKeys = schema?.rootKeys ?? new Set(getOwnSchemaKeys(rootState));
+	const sourceRecord = source;
+	const knownSliceEntries = schema?.sliceKeys;
+	if (isSliceStore && options.requireSliceRoots && knownSliceEntries) knownSliceEntries.forEach((_, key) => {
+		assertKnownSlicePresent(sourceRecord, key);
+	});
+	for (const key of getOwnEnumerableKeys(source)) {
+		assertKnownSchemaKey(rootKeys, key, []);
+		if (!isSliceStore) continue;
+		const slice = sourceRecord[key];
+		const knownSliceKeys = schema?.sliceKeys?.get(key) ?? (typeof rootState === "object" && rootState !== null && typeof rootState[key] === "object" && rootState[key] !== null ? new Set(getOwnSchemaKeys(rootState[key])) : void 0);
+		if (!knownSliceKeys) continue;
+		assertKnownSliceObject(key, slice);
+		for (const sliceKey of getOwnEnumerableKeys(slice)) assertKnownSchemaKey(knownSliceKeys, sliceKey, [key]);
+	}
+};
+const isArrayIndexKey$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;
+};
+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);
+	return target;
+};
+const sanitizeReplacementState = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeReplacementState(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey$2(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			const value = source[key];
+			if (typeof value === "function") continue;
+			setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		const value = source[key];
+		if (typeof value === "function") continue;
+		setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+	}
+	return target;
+};
+const sanitizeInitialStateValue = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeInitialStateValue(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey$2(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+	}
+	return target;
+};
+const areShallowEqualWithArray = (prev, next) => {
+	if (prev === null || next === null || prev.length !== next.length) return false;
+	const { length } = prev;
+	for (let i = 0; i < length; i += 1) {
+		if (Object.prototype.hasOwnProperty.call(prev, i) !== Object.prototype.hasOwnProperty.call(next, i)) return false;
+		if (!isEqual(prev[i], next[i])) return false;
+	}
+	return true;
+};
+const mergeObject = (target, source, isSlice) => {
+	if (isSlice) {
+		if (typeof source === "object" && source !== null) for (const key of getOwnEnumerableKeys(source)) {
+			if (typeof key === "string" && isUnsafeKey(key)) continue;
+			if (!Object.prototype.hasOwnProperty.call(target, key)) continue;
+			const sourceValue = source[key];
+			if (typeof sourceValue !== "object" || sourceValue === null) continue;
+			const targetValue = target[key];
+			if (typeof targetValue === "object" && targetValue !== null) assignOwnEnumerable(targetValue, sourceValue);
+		}
+	} else if (typeof source === "object" && source !== null) assignOwnEnumerable(target, source);
+};
+const uuid = () => {
+	let timestamp = (/* @__PURE__ */ new Date()).getTime();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+		const randomNum = (timestamp + Math.random() * 16) % 16 | 0;
+		timestamp = Math.floor(timestamp / 16);
+		return (char === "x" ? randomNum : randomNum & 3 | 8).toString(16);
+	});
+};
+//#endregion
+//#region packages/core/src/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 isArrayIndexKey$1 = (key, length) => {
+	if (key === "") return false;
+	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;
+		}
+	}
+};
+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;
+	}
+	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$1(key, value.length)) return {
+				type: "array-property",
+				path: nextPath
+			};
+			const violation = findJsonViolation(value[Number(key)], nextPath, ancestors);
+			if (violation) return violation;
+		}
+		ancestors.delete(value);
+		return;
+	}
+	if (!isPlainObject(value)) return {
+		type: "non-plain-object",
+		path
+	};
+	if (typeof value.toJSON === "function") return {
+		type: "to-json",
+		path
+	};
+	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;
+	}
+};
+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 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)}.`);
+};
+//#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);
+};
+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 previousAssertMutationAllowed = internal.assertMutationAllowed;
+	internal.assertMutationAllowed = (operation) => {
+		if (operation === "apply" && !isApplyingClientState) throw new Error(clientApplyErrorMessage);
+		previousAssertMutationAllowed?.(operation);
+	};
+	const baseApply = asyncClientStore.apply.bind(asyncClientStore);
+	asyncClientStore.apply = (state, patches) => {
+		if (!isApplyingClientState) throw new Error(clientApplyErrorMessage);
+		return baseApply(state, patches);
+	};
+	internal.applyClientState = (...args) => {
+		isApplyingClientState = true;
+		try {
+			baseApply(...args);
+		} finally {
+			isApplyingClientState = false;
+		}
+	};
+	const isSharedWorker = typeof SharedWorker !== "undefined" && asyncStoreClientOption.worker instanceof SharedWorker;
+	const transport = asyncStoreClientOption.worker ? (0, data_transport.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);
+		});
+	});
+	transport.listen("update", async (options) => {
+		let shouldFullSync = false;
+		let allowLowerSequence = false;
+		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) {
+				assertSafePatches(options.patches, "client transport update");
+				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);
+		} 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);
+		}
+	});
+	return wrapStore(asyncClientStore, () => asyncClientStore.getState());
+};
+const emit = (store, internal, patches) => {
+	const safePatches = sanitizePatches(patches, {
+		source: "transport emit",
+		warnOnDropped: true
+	});
+	if (store.transport && safePatches?.length) {
+		validateSharedStateSerializable(internal.rootState);
+		internal.sequence += 1;
+		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 = sanitizeCheckedPatches((store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	}).patches, "store.patch()");
+	if (safePatches.length) {
+		store.apply(internal.rootState, safePatches);
+		emit(store, internal, safePatches);
+	}
+};
+//#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/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;
+};
+const createClientAction = ({ clientExecuteSyncTimeoutMs, internal, key, store, sliceKey }) => {
+	return (...args) => {
+		internal.assertAlive?.(`action ${key}`);
+		let actionId;
+		let done;
+		if (store.trace) {
+			actionId = uuid();
+			store.trace({
+				method: key,
+				parameters: args,
+				id: actionId,
+				sliceKey
+			});
+			done = (result) => {
+				store.trace({
+					method: key,
+					id: actionId,
+					result,
+					sliceKey
+				});
+			};
+		}
+		const traceAction = (run) => {
+			try {
+				const result = run();
+				if (result instanceof Promise) return result.then((value) => {
+					done?.(value);
+					return value;
+				}, (error) => {
+					done?.(error);
+					throw error;
+				});
+				done?.(result);
+				return result;
+			} catch (error) {
+				done?.(error);
+				throw error;
+			}
+		};
+		if (typeof sliceKey === "symbol") throw new Error("Symbol-keyed slice actions are not supported in client store mode.");
+		const 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);
+						});
+					}, clientExecuteSyncTimeoutMs);
+				});
+			}
+			if (isTransportErrorEnvelope(result)) throw new Error(result.message);
+			if (isLegacyTransportErrorEnvelope(result)) throw new Error(result.$$Error);
+			return result;
+		}));
+	};
+};
+//#endregion
+//#region packages/core/src/getRawStateLocalAction.ts
+const getActionTarget = (store, sliceKey) => {
+	return typeof sliceKey !== "undefined" ? store.getState()[sliceKey] : store.getState();
+};
+const createLocalAction = ({ fn, internal, key, options, store, sliceKey }) => {
+	return (...args) => {
+		internal.assertAlive?.(`action ${String(key)}`);
+		let actionId;
+		let done;
+		if (store.trace) {
+			actionId = uuid();
+			store.trace({
+				method: String(key),
+				parameters: args,
+				id: actionId,
+				sliceKey
+			});
+			done = (result) => {
+				store.trace({
+					method: String(key),
+					id: actionId,
+					result,
+					sliceKey
+				});
+			};
+		}
+		const traceAction = (run) => {
+			try {
+				const result = run();
+				if (result instanceof Promise) return result.then((value) => {
+					done?.(value);
+					return value;
+				}, (error) => {
+					done?.(error);
+					throw error;
+				});
+				done?.(result);
+				return result;
+			} catch (error) {
+				done?.(error);
+				throw error;
+			}
+		};
+		const enablePatches = store.transport ?? options.enablePatches;
+		return traceAction(() => {
+			if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+				let result;
+				const handleResult = (isDrafted) => {
+					handleDraft(store, internal);
+					if (isDrafted) {
+						internal.backupState = internal.rootState;
+						const [draft, finalize] = (0, mutative.create)(internal.rootState, { enablePatches: true });
+						internal.finalizeDraft = finalize;
+						internal.rootState = draft;
+					}
+				};
+				const isDrafted = (0, mutative.isDraft)(internal.rootState);
+				if (isDrafted) handleResult();
+				internal.backupState = internal.rootState;
+				const [draft, finalize] = (0, mutative.create)(internal.rootState, { enablePatches: true });
+				internal.finalizeDraft = finalize;
+				internal.rootState = draft;
+				let asyncResult;
+				try {
+					result = fn.apply(getActionTarget(store, sliceKey), args);
+					if (result instanceof Promise) asyncResult = result;
+				} finally {
+					if (!asyncResult) handleResult(isDrafted);
+				}
+				if (asyncResult) return asyncResult.then((value) => {
+					handleResult(isDrafted);
+					return value;
+				}, (error) => {
+					handleResult(isDrafted);
+					throw error;
+				});
+				return result;
+			}
+			if (internal.mutableInstance && internal.actMutable) return internal.actMutable(() => {
+				return fn.apply(getActionTarget(store, sliceKey), args);
+			});
+			return fn.apply(getActionTarget(store, sliceKey), args);
+		});
+	};
+};
+//#endregion
+//#region packages/core/src/computed.ts
+const isObjectLike = (value) => typeof value === "object" && value !== null;
 var Computed = class {
-  constructor(deps, fn) {
-    this.deps = deps;
-    this.fn = fn;
-  }
-};
-var defaultMemoize = (func) => {
-  const lastArgs = /* @__PURE__ */ new WeakMap();
-  const lastResult = /* @__PURE__ */ new WeakMap();
-  return function() {
-    if (!areShallowEqualWithArray(lastArgs.get(this) ?? [], arguments)) {
-      lastResult.set(this, func.apply(this, arguments));
-    }
-    lastArgs.set(this, arguments);
-    return lastResult.get(this);
-  };
-};
-var createSelectorCreatorWithArray = (memoize = defaultMemoize) => {
-  return (dependenciesFunc, resultFunc) => {
-    const memoizedResultFunc = memoize(function() {
-      return resultFunc.apply(this, arguments);
-    });
-    return function() {
-      return memoizedResultFunc.apply(
-        this,
-        dependenciesFunc.apply(null, [this])
-      );
-    };
-  };
-};
-var createSelectorWithArray = createSelectorCreatorWithArray();
-
-// src/getRawStateStateProperty.ts
-var prepareStateDescriptor = ({
-  descriptor,
-  internal,
-  key,
-  rawState,
-  sliceKey
-}) => {
-  const isComputed = descriptor.value instanceof Computed;
-  if (internal.mutableInstance) {
-    Object.defineProperty(rawState, key, {
-      get: () => internal.mutableInstance[key],
-      set: (value) => {
-        internal.mutableInstance[key] = value;
-      },
-      enumerable: true
-    });
-  } else if (!isComputed) {
-    setOwnEnumerable(rawState, key, descriptor.value);
-  }
-  if (isComputed) {
-    if (internal.mutableInstance) {
-      throw new Error("Computed is not supported with mutable instance");
-    }
-    const { deps, fn } = descriptor.value;
-    const depsCallbackSelector = createSelectorWithArray(
-      // the root state should be updated, and the computed property will be updated.
-      () => [internal.rootState],
-      () => {
-        return deps(internal.module);
-      }
-    );
-    const selector = createSelectorWithArray(
-      (that) => depsCallbackSelector.call(that),
-      fn
-    );
-    descriptor.get = function() {
-      return selector.call(this);
-    };
-  } else if (sliceKey) {
-    descriptor.get = () => internal.rootState[sliceKey][key];
-    descriptor.set = (value) => {
-      internal.rootState[sliceKey][key] = value;
-    };
-  } else {
-    descriptor.get = () => internal.rootState[key];
-    descriptor.set = (value) => {
-      internal.rootState[key] = value;
-    };
-  }
-  delete descriptor.value;
-  delete descriptor.writable;
-};
-
-// src/getRawState.ts
-var defaultClientExecuteSyncTimeoutMs = 1500;
-var 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;
-};
-var getRawState = (store, internal, initialState, options) => {
-  const clientExecuteSyncTimeoutMs = getClientExecuteSyncTimeoutMs(options);
-  const rawState = {};
-  const handle = (_rawState, _initialState, sliceKey) => {
-    internal.mutableInstance = internal.toMutableRaw?.(_initialState);
-    const safeDescriptors = {};
-    const descriptors = Object.getOwnPropertyDescriptors(_initialState);
-    Reflect.ownKeys(descriptors).forEach((key) => {
-      if (typeof key === "string" && isUnsafeKey(key)) {
-        return;
-      }
-      safeDescriptors[key] = Reflect.get(descriptors, key);
-    });
-    Reflect.ownKeys(safeDescriptors).forEach((key) => {
-      const descriptor = safeDescriptors[key];
-      if (typeof descriptor === "undefined") {
-        return;
-      }
-      if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
-        if (typeof descriptor.value !== "function") {
-          prepareStateDescriptor({
-            descriptor,
-            internal,
-            key,
-            rawState: _rawState,
-            sliceKey
-          });
-          return;
-        }
-        if (typeof key !== "string") {
-          return;
-        }
-        if (store.share === "client") {
-          descriptor.value = createClientAction({
-            clientExecuteSyncTimeoutMs,
-            internal,
-            key,
-            store,
-            sliceKey
-          });
-        } else {
-          descriptor.value = createLocalAction({
-            fn: descriptor.value,
-            internal,
-            key,
-            options,
-            store,
-            sliceKey
-          });
-        }
-      }
-    });
-    const slice = Object.defineProperties({}, safeDescriptors);
-    return slice;
-  };
-  if (store.isSliceStore) {
-    internal.module = {};
-    Object.entries(initialState).forEach(([key, value]) => {
-      if (isUnsafeKey(key)) {
-        return;
-      }
-      const sliceRawState = {};
-      setOwnEnumerable(rawState, key, sliceRawState);
-      setOwnEnumerable(
-        internal.module,
-        key,
-        handle(sliceRawState, value, key)
-      );
-    });
-  } else {
-    internal.module = handle(rawState, initialState);
-  }
-  return rawState;
-};
-
-// src/handleState.ts
-var import_mutative2 = require("mutative");
-var handleState = (store, internal, options) => {
-  const setState = (next, updater = (next2) => {
-    const merge = (_next = next2) => {
-      mergeObject(internal.rootState, _next, store.isSliceStore);
-    };
-    const fn = typeof next2 === "function" ? () => {
-      const returnValue = next2(internal.module);
-      if (returnValue instanceof Promise) {
-        throw new Error(
-          "setState with async function is not supported"
-        );
-      }
-      if (typeof returnValue === "object" && returnValue !== null) {
-        merge(returnValue);
-      }
-    } : merge;
-    const enablePatches = store.transport ?? options.enablePatches;
-    if (!enablePatches && internal.mutableInstance) {
-      if (internal.actMutable) {
-        internal.actMutable(() => {
-          fn.apply(null);
-        });
-        return [];
-      }
-      fn.apply(null);
-      return [];
-    }
-    internal.backupState = internal.rootState;
-    let patches;
-    let inversePatches;
-    try {
-      const result = (0, import_mutative2.create)(
-        internal.rootState,
-        (draft) => {
-          internal.rootState = draft;
-          return fn.apply(null);
-        },
-        {
-          enablePatches: true
-        }
-      );
-      patches = result[1];
-      inversePatches = result[2];
-    } finally {
-      internal.rootState = internal.backupState;
-    }
-    const finalPatches = store.patch ? store.patch({ patches, inversePatches }) : { patches, inversePatches };
-    if (finalPatches.patches.length) {
-      store.apply(internal.rootState, finalPatches.patches);
-    }
-    return [
-      internal.rootState,
-      finalPatches.patches,
-      finalPatches.inversePatches
-    ];
-  }) => {
-    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 [];
-    }
-    internal.isBatching = true;
-    if (!store.share && !options.enablePatches && !internal.mutableInstance) {
-      if (typeof next === "function") {
-        try {
-          internal.backupState = internal.rootState;
-          internal.rootState = (0, import_mutative2.create)(
-            internal.rootState,
-            (draft) => {
-              internal.rootState = draft;
-              return next(internal.module);
-            }
-          );
-        } catch (error) {
-          internal.rootState = internal.backupState;
-          internal.isBatching = false;
-          throw error;
-        }
-      } else {
-        const copy = cloneOwnEnumerable(internal.rootState);
-        if (store.isSliceStore) {
-          for (const key of Object.keys(next)) {
-            if (!Object.prototype.hasOwnProperty.call(copy, key)) {
-              continue;
-            }
-            const sourceValue = next[key];
-            if (typeof sourceValue !== "object" || sourceValue === null) {
-              continue;
-            }
-            const targetValue = copy[key];
-            if (typeof targetValue !== "object" || targetValue === null) {
-              continue;
-            }
-            const sliceCopy = cloneOwnEnumerable(
-              targetValue
-            );
-            mergeObject(sliceCopy, sourceValue);
-            setOwnEnumerable(copy, key, sliceCopy);
-          }
-        } else {
-          mergeObject(copy, next);
-        }
-        internal.rootState = copy;
-      }
-      if (internal.updateImmutable) {
-        internal.updateImmutable(internal.rootState);
-      } else {
-        internal.listeners.forEach((listener) => listener());
-      }
-      internal.isBatching = false;
-      return [];
-    }
-    let result;
-    try {
-      const isDrafted = internal.mutableInstance && (0, import_mutative2.isDraft)(internal.rootState);
-      if (isDrafted) {
-        handleDraft(store, internal);
-      }
-      result = updater(next);
-      if (isDrafted) {
-        internal.backupState = internal.rootState;
-        const [draft, finalize] = (0, import_mutative2.create)(
-          internal.rootState,
-          {
-            enablePatches: true
-          }
-        );
-        internal.finalizeDraft = finalize;
-        internal.rootState = draft;
-      }
-    } finally {
-      internal.isBatching = false;
-    }
-    emit(store, internal, result?.[1]);
-    return result;
-  };
-  const getState = (deps, selector) => deps && selector ? new Computed(deps, selector) : internal.module;
-  return { setState, getState };
-};
-
-// src/applyMiddlewares.ts
-var 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";
-};
-var applyMiddlewares = (store, middlewares) => {
-  return middlewares.reduce((store2, middleware, index) => {
-    if (process.env.NODE_ENV === "development") {
-      if (typeof middleware !== "function") {
-        throw new Error(`middlewares[${index}] should be a function`);
-      }
-    }
-    const nextStore = middleware(store2);
-    if (process.env.NODE_ENV === "development") {
-      if (!isStoreLike(nextStore)) {
-        throw new Error(
-          `middlewares[${index}] should return a store-like object`
-        );
-      }
-    }
-    return nextStore;
-  }, store);
-};
-
-// src/handleMainTransport.ts
-var import_data_transport2 = require("data-transport");
-var getErrorMessage = (error) => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-};
-var transportErrorMarker2 = "__coactionTransportError__";
-var handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
-  const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? (0, import_data_transport2.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();
-    let obj = base;
-    try {
-      for (const key of keys) {
-        base = base[key];
-        if (typeof base === "function") {
-          base = base.bind(obj);
-        }
-        obj = base;
-      }
-      if (typeof base !== "function") {
-        throw new Error("The function is not found");
-      }
-      const result = await base(...args);
-      return [result, internal.sequence];
-    } catch (error) {
-      if (process.env.NODE_ENV === "development") {
-        console.error(error);
-      }
-      return [
-        {
-          [transportErrorMarker2]: true,
-          message: getErrorMessage(error)
-        },
-        internal.sequence
-      ];
-    }
-  });
-  transport.listen("fullSync", async () => {
-    return {
-      state: JSON.stringify(internal.rootState),
-      sequence: internal.sequence
-    };
-  });
-  store.transport = transport;
-};
-
-// src/create.ts
-var namespaceMap = /* @__PURE__ */ new Map();
-var hasWarnedAmbiguousFunctionMap = false;
-var isMainWorkerType = (workerType) => workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal";
-var isClientWorkerType = (workerType) => workerType === "SharedWorkerClient" || workerType === "WebWorkerClient";
-var validateCreateModeOptions = (options) => {
-  const storeTransport = options.transport;
-  const clientTransport = options.clientTransport;
-  const worker = options.worker;
-  const explicitWorkerType = options.workerType;
-  if (storeTransport && clientTransport) {
-    throw new Error(
-      "transport and clientTransport cannot be used together, please use one authority model per store."
-    );
-  }
-  if (storeTransport && worker) {
-    throw new Error(
-      "transport and worker cannot be used together, please use one authority model per store."
-    );
-  }
-  if (clientTransport && worker) {
-    throw new Error(
-      "clientTransport and worker cannot be used together, please use one client transport source."
-    );
-  }
-  if (isMainWorkerType(explicitWorkerType) && (clientTransport || worker)) {
-    throw new Error(
-      "main workerType cannot be combined with client transport settings."
-    );
-  }
-  if (isClientWorkerType(explicitWorkerType) && storeTransport) {
-    throw new Error("client workerType cannot be combined with transport.");
-  }
-};
-var 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(" ")
-  );
-};
-var 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: share2 }) => {
-    const store2 = {};
-    const internal2 = {
-      sequence: 0,
-      isBatching: false,
-      listeners: /* @__PURE__ */ new Set()
-    };
-    const name = options.name ?? defaultName;
-    const shouldTrackName = share2 === "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(store2, internal2, options);
-      const subscribe = (listener) => {
-        internal2.listeners.add(listener);
-        return () => internal2.listeners.delete(listener);
-      };
-      let isDestroyed = false;
-      const destroy = () => {
-        if (isDestroyed) {
-          return;
-        }
-        isDestroyed = true;
-        internal2.listeners.clear();
-        store2.transport?.dispose();
-        releaseStoreName();
-      };
-      const apply = (state = internal2.rootState, patches) => {
-        internal2.rootState = patches ? (0, import_mutative3.apply)(state, patches) : state;
-        if (internal2.updateImmutable) {
-          internal2.updateImmutable(internal2.rootState);
-        } else {
-          internal2.listeners.forEach((listener) => listener());
-        }
-      };
-      const getPureState = () => internal2.rootState;
-      const isFunctionMapObject = () => {
-        if (typeof createState === "object" && createState !== null) {
-          const values = Object.values(createState);
-          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(store2, {
-        name,
-        share: share2 ?? false,
-        setState,
-        getState,
-        subscribe,
-        destroy,
-        apply,
-        isSliceStore,
-        getPureState
-      });
-      const middlewareStore = applyMiddlewares(
-        store2,
-        options.middlewares ?? []
-      );
-      if (middlewareStore !== store2) {
-        Object.assign(store2, middlewareStore);
-      }
-      const initialState = getInitialState(store2, createState, internal2);
-      store2.getInitialState = () => initialState;
-      internal2.rootState = getRawState(
-        store2,
-        internal2,
-        initialState,
-        options
-      );
-      return { store: store2, internal: internal2 };
-    } 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`);
-    }
-    const store2 = createAsyncClientStore(
-      createStore,
-      options
-    );
-    return wrapStore(store2);
-  }
-  const { store, internal } = createStore({
-    share
-  });
-  handleMainTransport(
-    store,
-    internal,
-    storeTransport,
-    workerType,
-    checkEnablePatches
-  );
-  return wrapStore(store);
-};
-
-// src/binder.ts
-function createBinder({
-  handleState: handleState2,
-  handleStore
-}) {
-  return ((state) => {
-    const { copyState, key, bind } = handleState2(state);
-    const value = key ? copyState[key] : copyState;
-    value[bindSymbol] = {
-      handleStore,
-      bind
-    };
-    return copyState;
-  });
+	deps;
+	fn;
+	constructor(deps, fn) {
+		this.deps = deps;
+		this.fn = fn;
+	}
+	createGetter({ internal }) {
+		const memoByReceiver = /* @__PURE__ */ new WeakMap();
+		const lastArgs = /* @__PURE__ */ new WeakMap();
+		const lastResult = /* @__PURE__ */ new WeakMap();
+		const fallbackReceiver = {};
+		const evaluate = (receiver) => {
+			const args = this.deps(internal.module);
+			if (!lastArgs.has(receiver) || !areShallowEqualWithArray(lastArgs.get(receiver), args)) lastResult.set(receiver, this.fn.apply(receiver, args));
+			lastArgs.set(receiver, args);
+			return lastResult.get(receiver);
+		};
+		return function() {
+			const receiver = typeof this === "object" && this !== null ? this : fallbackReceiver;
+			if (internal.isBatching) return evaluate(receiver);
+			let accessor = memoByReceiver.get(receiver);
+			if (!accessor) {
+				accessor = (0, alien_signals.computed)(() => evaluate(receiver));
+				memoByReceiver.set(receiver, accessor);
+			}
+			return accessor();
+		};
+	}
+};
+const createCachedGetter = (internal, getter) => {
+	const accessors = /* @__PURE__ */ new WeakMap();
+	const fallbackReceiver = {};
+	return function() {
+		const receiver = typeof this === "object" && this !== null ? this : fallbackReceiver;
+		if (internal.isBatching) return getter.call(receiver);
+		let accessor = accessors.get(receiver);
+		if (!accessor) {
+			accessor = (0, alien_signals.computed)(() => getter.call(receiver));
+			accessors.set(receiver, accessor);
+		}
+		return accessor();
+	};
+};
+const createTrackedStateReader = (internal, read, initialValue) => {
+	const slotSignal = (0, alien_signals.signal)(initialValue);
+	const slotVersionSignal = (0, alien_signals.signal)(0);
+	let slotVersion = 0;
+	(internal.signalSlots ??= /* @__PURE__ */ new Set()).add({ refresh: () => {
+		const nextValue = read();
+		slotSignal(nextValue);
+		if (internal.mutableInstance && isObjectLike(nextValue)) {
+			slotVersion += 1;
+			slotVersionSignal(slotVersion);
+		}
+	} });
+	return () => {
+		const currentValue = slotSignal();
+		if (internal.mutableInstance && isObjectLike(currentValue)) slotVersionSignal();
+		return read();
+	};
+};
+const refreshSignalSlots = (internal) => {
+	if (!internal.signalSlots?.size) return;
+	(0, alien_signals.startBatch)();
+	try {
+		internal.signalSlots.forEach((slot) => slot.refresh());
+	} finally {
+		(0, alien_signals.endBatch)();
+	}
+};
+//#endregion
+//#region packages/core/src/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];
+	const initialValue = isComputed ? descriptor.value : sanitizeInitialStateValue(descriptor.value, initialStateSeen);
+	if (internal.mutableInstance) Object.defineProperty(rawState, key, {
+		get: () => internal.mutableInstance[key],
+		set: (value) => {
+			internal.mutableInstance[key] = value;
+		},
+		configurable: true,
+		enumerable: descriptor.enumerable
+	});
+	else if (!isComputed) Object.defineProperty(rawState, key, {
+		value: initialValue,
+		configurable: true,
+		enumerable: descriptor.enumerable,
+		writable: true
+	});
+	if (isComputed) {
+		if (internal.mutableInstance) throw new Error("Computed is not supported with mutable instance");
+		descriptor.get = descriptor.value.createGetter({ internal });
+	} else if (typeof sliceKey !== "undefined") {
+		const read = createTrackedStateReader(internal, readStateValue, initialValue);
+		descriptor.get = () => toReadonlyStateValue(internal, read(), sliceKey);
+		descriptor.set = (value) => {
+			assertImmutableStateMutationAllowed(internal);
+			internal.rootState[sliceKey][key] = value;
+		};
+	} else {
+		const read = createTrackedStateReader(internal, readStateValue, initialValue);
+		descriptor.get = () => toReadonlyStateValue(internal, read());
+		descriptor.set = (value) => {
+			assertImmutableStateMutationAllowed(internal);
+			internal.rootState[key] = value;
+		};
+	}
+	delete descriptor.value;
+	delete descriptor.writable;
+};
+const prepareAccessorDescriptor = ({ descriptor, internal }) => {
+	if (internal.mutableInstance || typeof descriptor.get !== "function") return;
+	descriptor.get = createCachedGetter(internal, descriptor.get);
+};
+//#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 clientExecuteSyncTimeoutMs = getClientExecuteSyncTimeoutMs(options);
+	const rawState = {};
+	const handle = (_rawState, _initialState, sliceKey) => {
+		internal.mutableInstance = internal.toMutableRaw?.(_initialState);
+		const initialStateSeen = /* @__PURE__ */ new WeakMap();
+		initialStateSeen.set(_initialState, _rawState);
+		const safeDescriptors = {};
+		const descriptors = Object.getOwnPropertyDescriptors(_initialState);
+		Reflect.ownKeys(descriptors).forEach((key) => {
+			if (typeof key === "string" && isUnsafeKey(key)) return;
+			safeDescriptors[key] = Reflect.get(descriptors, key);
+		});
+		Reflect.ownKeys(safeDescriptors).forEach((key) => {
+			const descriptor = safeDescriptors[key];
+			if (typeof descriptor === "undefined") return;
+			if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+				prepareAccessorDescriptor({
+					descriptor,
+					internal
+				});
+				return;
+			}
+			if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+				if (typeof descriptor.value !== "function") {
+					prepareStateDescriptor({
+						descriptor,
+						initialStateSeen,
+						internal,
+						key,
+						rawState: _rawState,
+						sliceKey
+					});
+					return;
+				}
+				if (store.share === "client") {
+					if (typeof key !== "string") return;
+					descriptor.value = createClientAction({
+						clientExecuteSyncTimeoutMs,
+						internal,
+						key,
+						store,
+						sliceKey
+					});
+				} else descriptor.value = createLocalAction({
+					fn: descriptor.value,
+					internal,
+					key,
+					options,
+					store,
+					sliceKey
+				});
+			}
+		});
+		return lockPublicStateObject(Object.defineProperties({}, safeDescriptors));
+	};
+	if (store.isSliceStore) {
+		internal.module = {};
+		getOwnEnumerableKeys(initialState).forEach((key) => {
+			if (typeof key === "string" && isUnsafeKey(key)) return;
+			const sliceRawState = {};
+			setOwnEnumerable(rawState, key, sliceRawState);
+			setOwnEnumerable(internal.module, key, handle(sliceRawState, initialState[key], key));
+		});
+		lockPublicStateObject(internal.module);
+	} else internal.module = handle(rawState, initialState);
+	return rawState;
+};
+//#endregion
+//#region packages/core/src/handleState.ts
+const handleState = (store, internal, options) => {
+	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) {
+				returnValue.catch(() => void 0);
+				throw new Error("setState with async function is not supported");
+			}
+			if (typeof returnValue === "object" && returnValue !== null) merge(returnValue);
+		} : merge;
+		if (!(store.transport ?? options.enablePatches) && internal.mutableInstance) {
+			if (internal.actMutable) {
+				internal.actMutable(() => {
+					fn.apply(null);
+				});
+				return [];
+			}
+			fn.apply(null);
+			return [];
+		}
+		internal.backupState = internal.rootState;
+		let patches;
+		let inversePatches;
+		try {
+			const result = (0, mutative.create)(internal.rootState, (draft) => {
+				internal.rootState = draft;
+				return fn.apply(null);
+			}, { enablePatches: true });
+			assertKnownStateShape(result[0], internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+			if (store.share === "main") validateSharedStateSerializable(result[0]);
+			patches = result[1];
+			inversePatches = result[2];
+		} finally {
+			internal.rootState = internal.backupState;
+		}
+		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) 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 && updater === defaultUpdater) try {
+			if (typeof next === "function") try {
+				internal.backupState = internal.rootState;
+				const nextState = (0, mutative.create)(internal.rootState, (draft) => {
+					internal.rootState = draft;
+					const returnValue = next(internal.module);
+					if (returnValue instanceof Promise) {
+						returnValue.catch(() => void 0);
+						throw new Error("setState with async function is not supported");
+					}
+					if (typeof returnValue === "object" && returnValue !== null) {
+						assertKnownStateShape(returnValue, internal.rootState, internal.stateSchema, store.isSliceStore);
+						mergeObject(internal.rootState, returnValue, store.isSliceStore);
+					}
+				});
+				assertKnownStateShape(nextState, internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				internal.rootState = nextState;
+			} catch (error) {
+				internal.rootState = internal.backupState;
+				throw error;
+			}
+			else {
+				const copy = cloneOwnEnumerable(internal.rootState);
+				if (store.isSliceStore) {
+					const nextRecord = next;
+					const copyRecord = copy;
+					for (const key of getOwnEnumerableKeys(nextRecord)) {
+						if (!Object.prototype.hasOwnProperty.call(copyRecord, key)) continue;
+						const sourceValue = nextRecord[key];
+						if (typeof sourceValue !== "object" || sourceValue === null) continue;
+						const targetValue = copyRecord[key];
+						if (typeof targetValue !== "object" || targetValue === null) continue;
+						const sliceCopy = cloneOwnEnumerable(targetValue);
+						mergeObject(sliceCopy, sourceValue);
+						setOwnEnumerable(copyRecord, key, sliceCopy);
+					}
+				} else mergeObject(copy, next);
+				assertKnownStateShape(copy, internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+				internal.rootState = copy;
+			}
+			refreshSignalSlots(internal);
+			if (internal.updateImmutable) internal.updateImmutable(internal.rootState);
+			else internal.listeners.forEach((listener) => listener());
+			return [];
+		} finally {
+			internal.isBatching = false;
+		}
+		let result;
+		try {
+			const isDrafted = internal.mutableInstance && (0, mutative.isDraft)(internal.rootState);
+			if (isDrafted) handleDraft(store, internal);
+			result = updater(next);
+			if (internal.mutableInstance) assertKnownStateShape(internal.rootState, internal.backupState ?? internal.rootState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
+			if (store.share === "main") validateSharedStateSerializable(internal.rootState);
+			if (isDrafted) {
+				internal.backupState = internal.rootState;
+				const [draft, finalize] = (0, mutative.create)(internal.rootState, { enablePatches: true });
+				internal.finalizeDraft = finalize;
+				internal.rootState = draft;
+			}
+		} finally {
+			internal.isBatching = false;
+		}
+		if (result?.length) result = [
+			result[0],
+			sanitizeCheckedPatches(result[1], "setState updater result"),
+			sanitizeCheckedPatches(result[2], "setState updater inverse result")
+		];
+		emit(store, internal, result?.[1]);
+		return result;
+	};
+	const getState = (deps, selector) => deps && selector ? new Computed(deps, selector) : internal.module;
+	return {
+		setState,
+		getState
+	};
+};
+//#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);
+};
+const transportErrorMarker = "__coactionTransportError__";
+const handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
+	const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? (0, data_transport.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);
+			}
+			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];
+		}
+	});
+	transport.listen("fullSync", async () => {
+		validateSharedStateSerializable(internal.rootState);
+		return {
+			state: JSON.stringify(internal.rootState),
+			sequence: internal.sequence
+		};
+	});
+	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);
+	}
+	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) => {
+	const storeTransport = options.transport;
+	const clientTransport = options.clientTransport;
+	const worker = options.worker;
+	const explicitWorkerType = options.workerType;
+	if (storeTransport && clientTransport) throw new Error("transport and clientTransport cannot be used together, please use one authority model per store.");
+	if (storeTransport && worker) throw new Error("transport and worker cannot be used together, please use one authority model per store.");
+	if (clientTransport && worker) throw new Error("clientTransport and worker cannot be used together, please use one client transport source.");
+	if (isMainWorkerType(explicitWorkerType) && (clientTransport || worker)) throw new Error("main workerType cannot be combined with client transport settings.");
+	if (isClientWorkerType(explicitWorkerType) && storeTransport) throw new Error("client workerType cannot be combined with transport.");
+};
+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.
+*/
+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.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;
+				internal.listeners.clear();
+				store.transport?.dispose();
+				releaseStoreName();
+			};
+			const apply = (state = internal.rootState, patches) => {
+				internal.assertAlive?.("apply");
+				internal.assertMutationAllowed?.("apply");
+				assertSafePatches(patches, "store.apply()");
+				const safePatches = sanitizePatches(patches);
+				const baseState = state === internal.module ? internal.rootState : state;
+				const nextState = sanitizeReplacementState(safePatches ? (0, mutative.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);
+				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,
+				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);
+			internal.stateSchema = createStateSchema(internal.rootState, store.isSliceStore);
+			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
+	});
+}
+/**
+* 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);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  createBinder,
-  wrapStore
+//#endregion
+//#region packages/core/src/reactiveTracker.ts
+const ReactiveFlags = alien_signals_system.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 (node.depsTail !== void 0) {
+		node.depsTail = void 0;
+		node.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+		purgeDeps(node);
+	}
+};
+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 = (0, alien_signals.setActiveSub)(node);
+			try {
+				return fn();
+			} finally {
+				(0, alien_signals.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] = (0, mutative.create)(internal.rootState, (draft) => {
+		replaceOwnEnumerable(draft, source);
+	}, { enablePatches: true });
+	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	}).patches, "store.patch()");
+	if (!safePatches.length) return;
+	const updateImmutable = internal.updateImmutable;
+	if (!syncImmutable) internal.updateImmutable = void 0;
+	try {
+		store.apply(internal.rootState, safePatches);
+	} finally {
+		internal.updateImmutable = updateImmutable;
+	}
+	emit(store, internal, safePatches);
+};
+//#endregion
+//#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, (0, mutative.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
+exports.StateSchemaError = StateSchemaError;
+exports.UnsafePatchPathError = UnsafePatchPathError;
+exports.applyMutableAdapterPatches = applyMutableAdapterPatches;
+exports.applyRootReplacementWithPatches = applyRootReplacementWithPatches;
+exports.assertSafePatches = assertSafePatches;
+Object.defineProperty(exports, "computed", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.computed;
+	}
+});
+exports.create = create;
+exports.createBinder = createBinder;
+exports.createReactiveTracker = createReactiveTracker;
+exports.createRootReplacementPatches = createRootReplacementPatches;
+exports.defineExternalStoreAdapter = defineExternalStoreAdapter;
+Object.defineProperty(exports, "effect", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.effect;
+	}
+});
+Object.defineProperty(exports, "effectScope", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.effectScope;
+	}
+});
+Object.defineProperty(exports, "endBatch", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.endBatch;
+	}
+});
+exports.getMutableAdapterOwnEnumerableKeys = getMutableAdapterOwnEnumerableKeys;
+Object.defineProperty(exports, "isComputed", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isComputed;
+	}
+});
+Object.defineProperty(exports, "isEffect", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isEffect;
+	}
+});
+Object.defineProperty(exports, "isEffectScope", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isEffectScope;
+	}
+});
+exports.isEqualMutableAdapterSnapshot = isEqualMutableAdapterSnapshot;
+exports.isMutableAdapterUnsafeKey = isMutableAdapterUnsafeKey;
+Object.defineProperty(exports, "isSignal", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.isSignal;
+	}
+});
+exports.isStateSchemaError = isStateSchemaError;
+exports.onStoreReady = onStoreReady;
+exports.replaceExternalStoreState = replaceExternalStoreState;
+exports.replaceMutableAdapterState = replaceMutableAdapterState;
+exports.replaceOwnEnumerable = replaceOwnEnumerable;
+exports.sanitizeInitialStateValue = sanitizeInitialStateValue;
+exports.sanitizePatches = sanitizePatches;
+exports.sanitizeReplacementState = sanitizeReplacementState;
+Object.defineProperty(exports, "signal", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.signal;
+	}
+});
+exports.snapshotMutableAdapterPureState = snapshotMutableAdapterPureState;
+Object.defineProperty(exports, "startBatch", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.startBatch;
+	}
+});
+exports.toMutableAdapterSnapshot = toMutableAdapterSnapshot;
+Object.defineProperty(exports, "trigger", {
+	enumerable: true,
+	get: function() {
+		return alien_signals.trigger;
+	}
 });
+exports.wrapStore = wrapStore;