coaction 1.5.0 → 2.0.0

package/dist/index.d.mts

@@ -1,17 +1,17 @@
-import { Transport } from 'data-transport';
-import { Draft, Patches } from 'mutative';
+import { Transport } from "data-transport";
+import { Draft, Patches } from "mutative";
+import { computed, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, signal, startBatch, trigger } from "alien-signals";
 
+//#region packages/core/src/interface.d.ts
 /**
  * Generic object shape used by stores and slices.
  */
-type ISlices<T = any> = Record<string, T>;
+type ISlices<T = any> = Record<PropertyKey, T>;
 /**
  * Recursive partial object accepted by {@link Store.setState} when merging a
  * plain object payload into the current state tree.
  */
-type DeepPartial<T> = {
-    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
-};
+type DeepPartial<T> = { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K] };
 /**
  * Subscription callback invoked after the store publishes a state change.
  */
@@ -20,33 +20,33 @@ type Listener = () => void;
  * Patch pair exposed to middleware compatibility hooks.
  */
 interface PatchTransform {
-    patches: Patches;
-    inversePatches: Patches;
+  patches: Patches;
+  inversePatches: Patches;
 }
 /**
  * Trace envelope emitted before and after a store method executes.
  */
 interface StoreTraceEvent {
-    /**
-     * The id of the method.
-     */
-    id: string;
-    /**
-     * The method name.
-     */
-    method: string;
-    /**
-     * The slice key.
-     */
-    sliceKey?: string;
-    /**
-     * The parameters of the method.
-     */
-    parameters?: any[];
-    /**
-     * The result of the method.
-     */
-    result?: any;
+  /**
+   * The id of the method.
+   */
+  id: string;
+  /**
+   * The method name.
+   */
+  method: string;
+  /**
+   * The slice key.
+   */
+  sliceKey?: PropertyKey;
+  /**
+   * The parameters of the method.
+   */
+  parameters?: any[];
+  /**
+   * The result of the method.
+   */
+  result?: any;
 }
 /**
  * Runtime store contract returned by {@link create} before framework-specific
@@ -58,92 +58,95 @@ interface StoreTraceEvent {
  * are later invoked.
  */
 interface Store<T extends ISlices = ISlices> {
-    /**
-     * The name of the store.
-     */
-    name: string;
-    /**
-     * Mutate the current state.
-     *
-     * @remarks
-     * Pass a deep-partial object to merge fields, or pass an updater to edit a
-     * Mutative draft. Passing `null` is a no-op. Client-side shared stores intentionally reject direct
-     * `setState()` calls; trigger a store method instead.
-     */
-    setState: (
-    /**
-     * The next partial state, or an updater that mutates a draft.
-     */
-    next: DeepPartial<T> | ((draft: Draft<T>) => any) | null, 
-    /**
-     * Low-level updater hook used by transports and middleware integrations.
-     */
-    updater?: (next: DeepPartial<T> | ((draft: Draft<T>) => any) | null) => [] | [T, Patches, Patches]) => void;
-    /**
-     * Read the current state object.
-     *
-     * @remarks
-     * The returned object includes methods and getters. Methods destructured from
-     * this object continue to execute against the latest store state.
-     */
-    getState: () => T;
-    /**
-     * Subscribe to state changes.
-     *
-     * @returns A function that removes the listener.
-     */
-    subscribe: (listener: Listener) => () => void;
-    /**
-     * Tear down the store.
-     *
-     * @remarks
-     * `destroy()` is idempotent. It clears subscriptions and disposes any
-     * attached transport.
-     */
-    destroy: () => void;
-    /**
-     * Indicates whether the store is local, the main shared store, or a client
-     * mirror of a shared store.
-     */
-    share?: 'main' | 'client' | false;
-    /**
-     * Transport used to synchronize a shared store between processes or threads.
-     */
-    transport?: Transport;
-    /**
-     * Whether `createState` was interpreted as a slices object.
-     */
-    isSliceStore: boolean;
-    /**
-     * Apply patches to the current state.
-     *
-     * @remarks
-     * This is a low-level hook used by transports and middleware. Application
-     * code should generally prefer store methods or `setState()`.
-     */
-    apply: (state?: T, patches?: Patches) => void;
-    /**
-     * Return the current state without methods or getters.
-     *
-     * @remarks
-     * Useful for serialization, inspection, or tests that only care about raw
-     * data.
-     */
-    getPureState: () => T;
-    /**
-     * Return the state produced during initialization before later mutations.
-     */
-    getInitialState: () => T;
-    /**
-     * @deprecated Middleware compatibility hook. Prefer typing middleware stores
-     * with `MiddlewareStore`.
-     */
-    patch?: (option: PatchTransform) => PatchTransform;
-    /**
-     * @deprecated Middleware compatibility hook. Prefer typing middleware stores
-     * with `MiddlewareStore`.
-     */
-    trace?: (options: StoreTraceEvent) => void;
+  /**
+   * The name of the store.
+   */
+  name: string;
+  /**
+   * Mutate the current state.
+   *
+   * @remarks
+   * Pass a deep-partial object to merge fields, or pass an updater to edit a
+   * Mutative draft. Passing `null` is a no-op. Client-side shared stores intentionally reject direct
+   * `setState()` calls; trigger a store method instead.
+   */
+  setState: (
+  /**
+   * The next partial state, or an updater that mutates a draft.
+   */
+
+  next: DeepPartial<T> | ((draft: Draft<T>) => any) | null,
+  /**
+   * Low-level updater hook used by transports and middleware integrations.
+   */
+
+  updater?: (next: DeepPartial<T> | ((draft: Draft<T>) => any) | null) => [] | [T, Patches, Patches]) => void;
+  /**
+   * Read the current state object.
+   *
+   * @remarks
+   * The returned object includes methods and getters. Methods destructured from
+   * this object continue to execute against the latest store state.
+   */
+  getState: () => T;
+  /**
+   * Subscribe to state changes.
+   *
+   * @returns A function that removes the listener.
+   */
+  subscribe: (listener: Listener) => () => void;
+  /**
+   * Tear down the store.
+   *
+   * @remarks
+   * `destroy()` is idempotent. It clears subscriptions and disposes any
+   * attached transport.
+   */
+  destroy: () => void;
+  /**
+   * Indicates whether the store is local, the main shared store, or a client
+   * mirror of a shared store.
+   */
+  share?: 'main' | 'client' | false;
+  /**
+   * Transport used to synchronize a shared store between processes or threads.
+   */
+  transport?: Transport;
+  /**
+   * Whether `createState` was interpreted as a slices object.
+   */
+  isSliceStore: boolean;
+  /**
+   * Apply patches to the current state.
+   *
+   * @remarks
+   * This is a low-level hook used by transports and middleware. Application
+   * code should generally prefer store methods or `setState()`. Client-side
+   * shared-store mirrors reject direct `apply()` calls.
+   */
+  apply: (state?: T, patches?: Patches) => void;
+  /**
+   * Return the current state without methods or getters.
+   *
+   * @remarks
+   * Useful for serialization, inspection, or tests that only care about raw
+   * data.
+   */
+  getPureState: () => T;
+  /**
+   * Return the state produced during initialization before later mutations.
+   */
+  getInitialState: () => T;
+  /**
+   * @deprecated Middleware compatibility hook. Prefer typing middleware stores
+   * with `MiddlewareStore`.
+   */
+  patch?: (option: PatchTransform) => PatchTransform;
+  /**
+   * @deprecated Middleware compatibility hook. Prefer typing middleware stores
+   * with `MiddlewareStore`.
+   */
+  trace?: (options: StoreTraceEvent) => void;
 }
 /**
  * Semantic alias for middleware-facing stores.
@@ -152,8 +155,7 @@ interface Store<T extends ISlices = ISlices> {
  * Middleware implementations should type their `store` parameter as
  * `MiddlewareStore` instead of relying on deprecated `patch` or `trace` hooks.
  */
-interface MiddlewareStore<T extends ISlices = ISlices> extends Store<T> {
-}
+interface MiddlewareStore<T extends ISlices = ISlices> extends Store<T> {}
 /**
  * Helper passed into {@link Slice} and {@link Slices} factories.
  *
@@ -162,8 +164,8 @@ interface MiddlewareStore<T extends ISlices = ISlices> extends Store<T> {
  * dependency selector pair to define a computed value.
  */
 interface Getter<T extends ISlices> {
-    <P extends any[], R>(getDeps: (store: T) => readonly [...P] | [...P], selector: (...args: P) => R): R;
-    (): T;
+  <P extends any[], R>(getDeps: (store: T) => readonly [...P] | [...P], selector: (...args: P) => R): R;
+  (): T;
 }
 /**
  * Factory for a single store object.
@@ -176,14 +178,17 @@ type Slice<T extends ISlices> = (
 /**
  * The setState is used to update the state.
  */
-set: Store<T>['setState'], 
+
+set: Store<T>['setState'],
 /**
  * The getState is used to get the state.
  */
-get: Getter<T>, 
+
+get: Getter<T>,
 /**
  * The store is used to store the state.
  */
+
 store: Store<T>) => T;
 /**
  * Factory for a named slice inside a slices store.
@@ -197,14 +202,17 @@ type Slices<T extends ISlices, K extends keyof T> = (
 /**
  * The setState is used to update the state.
  */
-set: Store<T>['setState'], 
+
+set: Store<T>['setState'],
 /**
  * The getState is used to get the state.
  */
-get: Getter<T>, 
+
+get: Getter<T>,
 /**
  * The store is used to store the state.
  */
+
 store: Store<T>) => T[K];
 /**
  * Store enhancer invoked during store creation.
@@ -218,48 +226,46 @@ type Middleware<T extends CreateState> = (store: MiddlewareStore<T>) => Middlewa
  * Derived state object produced by mapping slice factories to their return
  * types.
  */
-type SliceState<T extends Record<string, Slice<any>>> = {
-    [K in keyof T]: ReturnType<T[K]>;
-};
+type SliceState<T extends Record<PropertyKey, Slice<any>>> = { [K in keyof T]: ReturnType<T[K]> };
 /**
  * Options for creating a local store or the main side of a shared store.
  */
 type StoreOptions<T extends CreateState> = {
-    /**
-     * The name of the store.
-     */
-    name?: string;
-    /**
-     * @deprecated Internal worker-mode override retained for compatibility.
-     * Prefer passing `transport` or letting the runtime infer the environment.
-     */
-    workerType?: 'SharedWorkerInternal' | 'WebWorkerInternal';
-    /**
-     * Inject a pre-built transport for advanced shared-store setups.
-     */
-    transport?: Transport;
-    /**
-     * Middleware chain applied before the initial state is finalized.
-     */
-    middlewares?: Middleware<T>[];
-    /**
-     * Enable patch generation.
-     *
-     * @remarks
-     * Required for async client stores and useful for middleware or mutable
-     * integrations that depend on patch streams.
-     */
-    enablePatches?: boolean;
-    /**
-     * Control how `createState` should be interpreted.
-     *
-     * @remarks
-     * - auto: infer from createState shape. Object maps whose values are all
-     *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
-     * - slices: force slices mode.
-     * - single: force single-store mode.
-     */
-    sliceMode?: 'auto' | 'slices' | 'single';
+  /**
+   * The name of the store.
+   */
+  name?: string;
+  /**
+   * @deprecated Internal worker-mode override retained for compatibility.
+   * Prefer passing `transport` or letting the runtime infer the environment.
+   */
+  workerType?: 'SharedWorkerInternal' | 'WebWorkerInternal';
+  /**
+   * Inject a pre-built transport for advanced shared-store setups.
+   */
+  transport?: Transport;
+  /**
+   * Middleware chain applied before the initial state is finalized.
+   */
+  middlewares?: Middleware<T>[];
+  /**
+   * Enable patch generation.
+   *
+   * @remarks
+   * Required for async client stores and useful for middleware or mutable
+   * integrations that depend on patch streams.
+   */
+  enablePatches?: boolean;
+  /**
+   * Control how `createState` should be interpreted.
+   *
+   * @remarks
+   * - auto: infer from createState shape. Object maps whose values are all
+   *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
+   * - slices: force slices mode.
+   * - single: force single-store mode.
+   */
+  sliceMode?: 'auto' | 'slices' | 'single';
 };
 /**
  * Options for creating a client mirror of a shared store.
@@ -269,61 +275,57 @@ type StoreOptions<T extends CreateState> = {
  * execution happens on the main/shared store.
  */
 type ClientStoreOptions<T extends CreateState> = {
-    /**
-     * The name of the shared store to connect to.
-     */
-    name?: string;
-    /**
-     * Middleware chain applied to the client-side store wrapper.
-     */
-    middlewares?: Middleware<T>[];
-    /**
-     * Control how `createState` should be interpreted.
-     *
-     * @remarks
-     * - auto: infer from createState shape. Object maps whose values are all
-     *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
-     * - slices: force slices mode.
-     * - single: force single-store mode.
-     */
-    sliceMode?: 'auto' | 'slices' | 'single';
+  /**
+   * The name of the shared store to connect to.
+   */
+  name?: string;
+  /**
+   * Middleware chain applied to the client-side store wrapper.
+   */
+  middlewares?: Middleware<T>[];
+  /**
+   * Control how `createState` should be interpreted.
+   *
+   * @remarks
+   * - auto: infer from createState shape. Object maps whose values are all
+   *   functions are ambiguous, so prefer setting `sliceMode` explicitly.
+   * - slices: force slices mode.
+   * - single: force single-store mode.
+   */
+  sliceMode?: 'auto' | 'slices' | 'single';
 } & ClientTransportOptions;
 /**
  * Transport-related options for client/shared-store mirrors.
  */
 interface ClientTransportOptions {
-    /**
-     * @deprecated Internal worker-mode override retained for compatibility.
-     * Prefer passing `clientTransport` or `worker`.
-     */
-    workerType?: 'WebWorkerClient' | 'SharedWorkerClient';
-    /**
-     * How long the client should wait for sequence catch-up before falling back
-     * to `fullSync`.
-     *
-     * Increase this when worker-side execution can complete before the matching
-     * incremental `update` message arrives under heavy load.
-     *
-     * @default 1500
-     */
-    executeSyncTimeoutMs?: number;
-    /**
-     * Inject a pre-built client transport.
-     */
-    clientTransport?: Transport<any>;
-    /**
-     * Build a client transport from a Worker or SharedWorker instance.
-     */
-    worker?: SharedWorker | Worker;
+  /**
+   * @deprecated Internal worker-mode override retained for compatibility.
+   * Prefer passing `clientTransport` or `worker`.
+   */
+  workerType?: 'WebWorkerClient' | 'SharedWorkerClient';
+  /**
+   * How long the client should wait for sequence catch-up before falling back
+   * to `fullSync`.
+   *
+   * Increase this when worker-side execution can complete before the matching
+   * incremental `update` message arrives under heavy load.
+   *
+   * @default 1500
+   */
+  executeSyncTimeoutMs?: number;
+  /**
+   * Inject a pre-built client transport.
+   */
+  clientTransport?: Transport<any>;
+  /**
+   * Build a client transport from a Worker or SharedWorker instance.
+   */
+  worker?: SharedWorker | Worker;
 }
 /**
  * Transform store methods into promise-returning methods for client stores.
  */
-type Asyncify<T extends object, D extends true | false> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>> : D extends false ? T[K] : {
-        [P in keyof T[K]]: T[K][P] extends (...args: any[]) => any ? (...args: Parameters<T[K][P]>) => Promise<ReturnType<T[K][P]>> : T[K][P];
-    };
-};
+type Asyncify<T extends object, D extends true | false> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? (...args: Parameters<T[K]>) => Promise<Awaited<ReturnType<T[K]>>> : D extends false ? T[K] : { [P in keyof T[K]]: T[K][P] extends ((...args: any[]) => any) ? (...args: Parameters<T[K][P]>) => Promise<Awaited<ReturnType<T[K][P]>>> : T[K][P] } };
 /**
  * Store shape returned by {@link create} when acting as a client of a shared
  * store.
@@ -343,7 +345,13 @@ type StoreReturn<T extends object> = Store<T> & ((...args: any[]) => T);
  * This can be either a single store factory/object or a map of slice
  * factories.
  */
-type CreateState = ISlices | Record<string, Slice<any>>;
+type CreateState = ISlices | Record<PropertyKey, Slice<any>>;
+type SingleStoreOptions<T extends CreateState> = StoreOptions<T> & {
+  sliceMode: 'single';
+};
+type SingleClientStoreOptions<T extends CreateState> = ClientStoreOptions<T> & {
+  sliceMode: 'single';
+};
 /**
  * Overload set for {@link create}.
  *
@@ -357,12 +365,15 @@ type CreateState = ISlices | Record<string, Slice<any>>;
  * `sliceMode` to avoid ambiguous inference.
  */
 type Creator = {
-    <T extends Record<string, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
-    <T extends ISlices>(createState: Slice<T>, options?: StoreOptions<T>): StoreReturn<T>;
-    <T extends Record<string, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
-    <T extends ISlices>(createState: Slice<T>, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends ISlices>(createState: T, options: SingleStoreOptions<T>): StoreReturn<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: StoreOptions<T>): StoreReturn<SliceState<T>>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: StoreOptions<T>): StoreReturn<T>;
+  <T extends ISlices>(createState: T, options: SingleClientStoreOptions<T>): StoreWithAsyncFunction<T>;
+  <T extends Record<PropertyKey, Slice<any>>>(createState: T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<SliceState<T>, true>;
+  <T extends ISlices>(createState: Slice<T> | T, options?: ClientStoreOptions<T>): StoreWithAsyncFunction<T>;
 };
-
+//#endregion
+//#region packages/core/src/create.d.ts
 /**
  * Create a local store, the main side of a shared store, or a client mirror of
  * a shared store.
@@ -379,54 +390,128 @@ type Creator = {
  *   ambiguous `create()` input forms.
  */
 declare const create: Creator;
-
+//#endregion
+//#region packages/core/src/internal.d.ts
+type MutationOperation = 'setState' | 'apply';
+type SignalSlot = {
+  refresh: () => void;
+};
 interface Internal<T extends CreateState = CreateState> {
-    /**
-     * The store module.
-     */
-    module: T;
-    /**
-     * The root state.
-     */
-    rootState: T | Draft<T>;
-    /**
-     * The backup state.
-     */
-    backupState: T | Draft<T>;
-    /**
-     * Finalize the draft.
-     */
-    finalizeDraft: () => [T, Patches, Patches];
-    /**
-     * The mutable instance.
-     */
-    mutableInstance: any;
-    /**
-     * The sequence number.
-     */
-    sequence: number;
-    /**
-     * Whether the batch is running.
-     */
-    isBatching: boolean;
-    /**
-     * The listeners.
-     */
-    listeners: Set<Listener>;
-    /**
-     * The act is used to run the function in the action for mutable state.
-     */
-    actMutable?: <T extends () => any>(fn: T) => ReturnType<T>;
-    /**
-     * Get the mutable raw instance via the initial state.
-     */
-    toMutableRaw?: (key: any) => any;
-    /**
-     * The update immutable function.
-     */
-    updateImmutable?: (state: T) => void;
+  /**
+   * The store module.
+   */
+  module: T;
+  /**
+   * The root state.
+   */
+  rootState: T | Draft<T>;
+  /**
+   * The backup state.
+   */
+  backupState: T | Draft<T>;
+  /**
+   * Finalize the draft.
+   */
+  finalizeDraft: () => [T, Patches, Patches];
+  /**
+   * The mutable instance.
+   */
+  mutableInstance: any;
+  /**
+   * The sequence number.
+   */
+  sequence: number;
+  /**
+   * Whether the batch is running.
+   */
+  isBatching: boolean;
+  /**
+   * The listeners.
+   */
+  listeners: Set<Listener>;
+  /**
+   * Publish an externally-owned immutable state change to signal slots and
+   * store subscribers.
+   */
+  notifyStateChange: () => void;
+  /**
+   * Reactive state slots used by computed getters/selectors.
+   */
+  signalSlots?: Set<SignalSlot>;
+  /**
+   * The act is used to run the function in the action for mutable state.
+   */
+  actMutable?: <T extends () => any>(fn: T) => ReturnType<T>;
+  /**
+   * Get the mutable raw instance via the initial state.
+   */
+  toMutableRaw?: (key: any) => any;
+  /**
+   * The update immutable function.
+   */
+  updateImmutable?: (state: T) => void;
+  /**
+   * Adapter-level authority check for low-level mutations.
+   */
+  assertMutationAllowed?: (operation: MutationOperation) => void;
+  /**
+   * Authorized client-mirror state application used by transports.
+   */
+  applyClientState?: (state?: T, patches?: Patches) => void;
 }
+//#endregion
+//#region packages/core/src/binder.d.ts
+type ExternalStoreAdapterOptions<F = (...args: any[]) => any> = {
+  /**
+   * Normalize a third-party store instance into a raw state object plus the
+   * binding hook used during initialization.
+   */
+  handleState: <T extends object = object>(state: T) => {
+    /**
+     * Copy of the incoming state object that Coaction should consume.
+     */
+    copyState: T;
+    /**
+     * Optional nested key when the adapter exposes a single child object from
+     * the third-party store.
+     */
+    key?: keyof T;
+    /**
+     * Convert the external state object into the raw state shape used by
+     * Coaction.
+     */
+    bind: (state: T) => T;
+  };
+  /**
+   * Wire Coaction's store lifecycle to the external store implementation.
+   */
+  handleStore: (
+  /**
+   * Coaction store wrapper.
+   */
+
+  store: Store<object>,
+  /**
+   * Raw state object returned from `bind`.
+   */
+
+  rawState: object,
+  /**
+   * Original external store state object.
+   */
+
+  state: object,
+  /**
+   * Low-level Coaction adapter hooks used by official bindings.
+   */
+
+  internal: Internal<object>,
+  /**
+   * Optional nested key returned by `handleState`.
+   */
 
+  key?: PropertyKey) => void;
+};
 /**
  * Build an adapter helper for bridging an external store implementation into
  * Coaction.
@@ -436,53 +521,46 @@ interface Internal<T extends CreateState = CreateState> {
  * Zustand, MobX, and Valtio. Binder-backed integrations are whole-store
  * adapters; they are not compatible with Coaction slices mode.
  */
-declare function createBinder<F = (...args: any[]) => any>({ handleState, handleStore }: {
-    /**
-     * Normalize a third-party store instance into a raw state object plus the
-     * binding hook used during initialization.
-     */
-    handleState: <T extends object = object>(state: T) => {
-        /**
-         * Copy of the incoming state object that Coaction should consume.
-         */
-        copyState: T;
-        /**
-         * Optional nested key when the adapter exposes a single child object from
-         * the third-party store.
-         */
-        key?: keyof T;
-        /**
-         * Convert the external state object into the raw state shape used by
-         * Coaction.
-         */
-        bind: (state: T) => T;
-    };
-    /**
-     * Wire Coaction's store lifecycle to the external store implementation.
-     */
-    handleStore: (
-    /**
-     * Coaction store wrapper.
-     */
-    store: Store<object>, 
-    /**
-     * Raw state object returned from `bind`.
-     */
-    rawState: object, 
-    /**
-     * Original external store state object.
-     */
-    state: object, 
-    /**
-     * Low-level Coaction adapter hooks used by official bindings.
-     */
-    internal: Internal<object>, 
-    /**
-     * Optional nested key returned by `handleState`.
-     */
-    key?: string) => void;
-}): F;
-
+declare function createBinder<F = (...args: any[]) => any>({
+  handleState,
+  handleStore
+}: ExternalStoreAdapterOptions<F>): F;
+/**
+ * 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.
+ */
+declare function defineExternalStoreAdapter<F = (...args: any[]) => any>(options: ExternalStoreAdapterOptions<F>): F;
+//#endregion
+//#region packages/core/src/lifecycle.d.ts
+declare const onStoreReady: <T extends CreateState>(store: Store<T>, callback: () => void) => () => void;
+//#endregion
+//#region packages/core/src/reactiveTracker.d.ts
+type ReactiveTracker = {
+  getSnapshot: () => number;
+  subscribe: (listener: () => void) => () => void;
+  track: <T>(fn: () => T) => T;
+  dispose: () => void;
+};
+declare const createReactiveTracker: () => ReactiveTracker;
+//#endregion
+//#region packages/core/src/replaceExternalStoreState.d.ts
+type ReplaceExternalStoreStateOptions = {
+  syncImmutable?: boolean;
+};
+declare const replaceExternalStoreState: <T extends CreateState>(store: MiddlewareStore<T>, internal: Internal<T>, source: Record<PropertyKey, unknown>, {
+  syncImmutable
+}?: ReplaceExternalStoreStateOptions) => void;
+//#endregion
+//#region packages/core/src/utils.d.ts
+declare const replaceOwnEnumerable: (target: Record<PropertyKey, unknown>, source: Record<PropertyKey, unknown>) => void;
+declare const sanitizeReplacementState: <T>(source: T, seen?: WeakMap<object, unknown>) => T;
+declare const sanitizeInitialStateValue: <T>(source: T, seen?: WeakMap<object, unknown>) => T;
+//#endregion
+//#region packages/core/src/wrapStore.d.ts
 /**
  * Convert a store object into Coaction's callable store shape.
  *
@@ -493,5 +571,5 @@ declare function createBinder<F = (...args: any[]) => any>({ handleState, handle
  * directly.
  */
 declare const wrapStore: <T extends object>(store: Store<T>, getState?: (...args: unknown[]) => T) => StoreReturn<T>;
-
-export { type StoreWithAsyncFunction as AsyncStore, type Asyncify, type ClientStoreOptions, type ISlices, type Middleware, type MiddlewareStore, type PatchTransform, type Slice, type SliceState, type Slices, type Store, type StoreOptions, type StoreTraceEvent, create, createBinder, wrapStore };
+//#endregion
+export { type StoreWithAsyncFunction as AsyncStore, type Asyncify, type ClientStoreOptions, type ExternalStoreAdapterOptions, type ISlices, type Middleware, type MiddlewareStore, type PatchTransform, type ReactiveTracker, type Slice, type SliceState, type Slices, type Store, type StoreOptions, type StoreTraceEvent, computed, create, createBinder, createReactiveTracker, defineExternalStoreAdapter, effect, effectScope, endBatch, isComputed, isEffect, isEffectScope, isSignal, onStoreReady, replaceExternalStoreState, replaceOwnEnumerable, sanitizeInitialStateValue, sanitizeReplacementState, signal, startBatch, trigger, wrapStore };