sibujs 1.3.0 → 1.5.0

package/dist/index.js

@@ -24,8 +24,6 @@ import {
   lazy,
   longPress,
   match,
-  memo,
-  memoFn,
   mount,
   nextTick,
   onCleanup,
@@ -45,7 +43,7 @@ import {
   unregisterComponent,
   when,
   writable
-} from "./chunk-QWZG56ET.js";
+} from "./chunk-JCDUJN2F.js";
 import {
   __resetIdCounter,
   createId
@@ -187,31 +185,31 @@ import {
   use,
   var_,
   video
-} from "./chunk-32DY64NT.js";
+} from "./chunk-P3XWXJZU.js";
 import {
   watch
-} from "./chunk-NYVAC6P5.js";
+} from "./chunk-GJPXRJ45.js";
 import {
   context
-} from "./chunk-BGN5ZMP4.js";
+} from "./chunk-6BMPXPUW.js";
 import {
   SVG_NS,
   tagFactory
-} from "./chunk-F3FA4F32.js";
+} from "./chunk-SFKNRVCU.js";
 import {
   bindDynamic,
   checkLeaks,
   dispose,
   registerDisposer
-} from "./chunk-PTQJDMRT.js";
+} from "./chunk-5ZYQ6KDD.js";
 import {
   derived
-} from "./chunk-NEKUBFPT.js";
+} from "./chunk-XHK6BDAJ.js";
 import "./chunk-CMBFNA7L.js";
 import {
   effect,
   on
-} from "./chunk-CHF5OHIA.js";
+} from "./chunk-VQNQZCWJ.js";
 import {
   disableSSR,
   enableSSR,
@@ -223,10 +221,10 @@ import {
   enqueueBatchedSignal,
   isBatching,
   signal
-} from "./chunk-WZSPOOER.js";
+} from "./chunk-NZIIMDWI.js";
 import {
   untracked
-} from "./chunk-ZD6OAMTH.js";
+} from "./chunk-K4G4ZQNR.js";
 import "./chunk-5X6PP2UK.js";
 export {
   DynamicComponent,
@@ -343,8 +341,6 @@ export {
   mask,
   match,
   math,
-  memo,
-  memoFn,
   menu,
   meta,
   meter,

package/dist/motion.cjs

@@ -57,20 +57,29 @@ function transition(element, options = {}) {
     onLeaveDone
   } = options;
   const transitionValue = `${property} ${duration}ms ${easing} ${delay}ms`;
+  let activeTimer = null;
+  function cancelPending() {
+    if (activeTimer !== null) {
+      clearTimeout(activeTimer);
+      activeTimer = null;
+    }
+  }
   function enter() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (enterClass) element.classList.add(enterClass);
       if (leaveClass) element.classList.remove(leaveClass);
       void element.offsetHeight;
       if (activeClass) element.classList.add(activeClass);
       const done = () => {
+        activeTimer = null;
         if (enterClass) element.classList.remove(enterClass);
         onEnterDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }
@@ -78,17 +87,19 @@ function transition(element, options = {}) {
   }
   function leave() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (activeClass) element.classList.remove(activeClass);
       if (leaveClass) element.classList.add(leaveClass);
       if (enterClass) element.classList.remove(enterClass);
       const done = () => {
+        activeTimer = null;
         if (leaveClass) element.classList.remove(leaveClass);
         onLeaveDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }

package/dist/motion.d.cts

@@ -32,7 +32,7 @@ interface TransitionOptions {
  *
  * @example
  * ```ts
- * const box = div({ class: "box", nodes: "Hello" });
+ * const box = div("box", "Hello");
  * const { enter, leave } = transition(box, {
  *   duration: 300,
  *   enterClass: "fade-in",

package/dist/motion.d.ts

@@ -32,7 +32,7 @@ interface TransitionOptions {
  *
  * @example
  * ```ts
- * const box = div({ class: "box", nodes: "Hello" });
+ * const box = div("box", "Hello");
  * const { enter, leave } = transition(box, {
  *   duration: 300,
  *   enterClass: "fade-in",

package/dist/motion.js

@@ -19,9 +19,9 @@ import {
   stagger,
   transition,
   viewTransition
-} from "./chunk-KQPDEVVS.js";
-import "./chunk-WZSPOOER.js";
-import "./chunk-ZD6OAMTH.js";
+} from "./chunk-XUEEGU5O.js";
+import "./chunk-NZIIMDWI.js";
+import "./chunk-K4G4ZQNR.js";
 import "./chunk-5X6PP2UK.js";
 export {
   TransitionGroup,

package/dist/patterns.cjs

@@ -22,12 +22,8 @@ var patterns_exports = {};
 __export(patterns_exports, {
   RenderProp: () => RenderProp,
   assertType: () => assertType,
-  composable: () => composable,
   compose: () => compose,
-  createEffect: () => createEffect,
   createGuard: () => createGuard,
-  createMemo: () => createMemo,
-  createSignal: () => createSignal,
   createSlots: () => createSlots,
   defineComponent: () => defineComponent,
   defineSlottedComponent: () => defineSlottedComponent,
@@ -434,7 +430,7 @@ function persisted(key, initial, options = {}) {
   }
   const [value, setValue] = signal(restored);
   let applyingFromStorage = false;
-  effect(() => {
+  const stopPersistEffect = effect(() => {
     const current = value();
     if (applyingFromStorage) return;
     try {
@@ -474,6 +470,7 @@ function persisted(key, initial, options = {}) {
     window.addEventListener("storage", storageListener);
   }
   const dispose = () => {
+    stopPersistEffect();
     if (storageListener && typeof window !== "undefined") {
       window.removeEventListener("storage", storageListener);
       storageListener = null;
@@ -491,27 +488,53 @@ function persisted(key, initial, options = {}) {
 // src/patterns/optimistic.ts
 function optimistic(initialValue) {
   const [value, setValue] = signal(initialValue);
-  const [_pending, setPending] = signal(false);
-  async function addOptimistic(optimisticValue, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  async function update(optimisticValue, asyncAction) {
+    const myVersion = ++version;
     const previousValue = value();
     setValue(optimisticValue);
+    inflightCount++;
     setPending(true);
     try {
       const result = await asyncAction();
-      setValue(result);
+      if (version === myVersion) {
+        setValue(result);
+      }
     } catch {
-      setValue(previousValue);
+      if (version === myVersion) {
+        setValue(previousValue);
+      }
     } finally {
-      setPending(false);
+      inflightCount--;
+      if (inflightCount === 0) setPending(false);
     }
   }
-  return [value, addOptimistic];
+  return { value, pending, update };
 }
 function optimisticList(initialValue) {
   const [items, setItems] = signal([...initialValue]);
-  async function addOptimistic(item, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  function begin() {
+    const v = ++version;
+    inflightCount++;
+    setPending(true);
+    return v;
+  }
+  function end(myVersion, revertFn) {
+    if (revertFn && version === myVersion) {
+      revertFn();
+    }
+    inflightCount--;
+    if (inflightCount === 0) setPending(false);
+  }
+  async function add(item, asyncAction) {
     const prev = items();
     setItems([...prev, item]);
+    const myVersion = begin();
     try {
       const result = await asyncAction();
       setItems((current) => {
@@ -521,32 +544,56 @@ function optimisticList(initialValue) {
           next[idx] = result;
           return next;
         }
-        return [...current.filter((i) => i !== item), result];
+        return [...current, result];
       });
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function removeOptimistic(predicate, asyncAction) {
+  async function remove(predicate, asyncAction) {
     const prev = items();
     setItems(prev.filter((item) => !predicate(item)));
+    const myVersion = begin();
     try {
       await asyncAction();
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function updateOptimistic(predicate, update, asyncAction) {
+  async function updateItem(predicate, patch, asyncAction) {
     const prev = items();
-    setItems(prev.map((item) => predicate(item) ? { ...item, ...update } : item));
+    const patchedRefs = [];
+    setItems(
+      prev.map((item) => {
+        if (predicate(item)) {
+          const patched = { ...item, ...patch };
+          patchedRefs.push(patched);
+          return patched;
+        }
+        return item;
+      })
+    );
+    const myVersion = begin();
     try {
       const result = await asyncAction();
-      setItems((current) => current.map((item) => predicate(item) ? result : item));
+      setItems((current) => current.map((item) => patchedRefs.includes(item) ? result : item));
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  return { items, addOptimistic, removeOptimistic, updateOptimistic };
+  return {
+    items,
+    pending,
+    add,
+    remove,
+    update: updateItem,
+    addOptimistic: add,
+    removeOptimistic: remove,
+    updateOptimistic: updateItem
+  };
 }
 
 // src/core/signals/derived.ts
@@ -567,21 +614,37 @@ function derived(getter, options) {
     cs._v = getter();
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  let evaluating = false;
   function computedGetter() {
+    if (evaluating) {
+      throw new Error(
+        `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
+      );
+    }
     if (trackingSuspended) {
       if (cs._d) {
-        cs._d = false;
-        cs._v = getter();
+        evaluating = true;
+        try {
+          cs._d = false;
+          cs._v = getter();
+        } finally {
+          evaluating = false;
+        }
       }
       return cs._v;
     }
     recordDependency(cs);
     if (cs._d) {
       const oldValue = cs._v;
-      track(() => {
-        cs._d = false;
-        cs._v = getter();
-      }, markDirty);
+      evaluating = true;
+      try {
+        track(() => {
+          cs._d = false;
+          cs._v = getter();
+        }, markDirty);
+      } finally {
+        evaluating = false;
+      }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
       }
@@ -646,7 +709,7 @@ function timeline(initial, maxHistory = 100) {
 
 // src/patterns/globalStore.ts
 function globalStore(config) {
-  const initialState = { ...config.state };
+  const initialState = JSON.parse(JSON.stringify(config.state));
   const [getState, setState] = signal({ ...initialState });
   const listeners = /* @__PURE__ */ new Set();
   const middlewares = config.middleware || [];
@@ -699,17 +762,6 @@ function globalStore(config) {
   return { getState, select, dispatch, subscribe, reset };
 }
 
-// src/patterns/primitives.ts
-function createSignal(value) {
-  return signal(value);
-}
-function createMemo(fn) {
-  return derived(fn);
-}
-function createEffect(fn) {
-  return effect(fn);
-}
-
 // src/patterns/hoc.ts
 function withWrapper(WrappedComponent, wrapper) {
   return (props) => wrapper(WrappedComponent, props);
@@ -722,9 +774,6 @@ function compose(...wrappers) {
 }
 
 // src/patterns/composable.ts
-function composable(setup) {
-  return setup;
-}
 function RenderProp(props) {
   return props.render(props.data());
 }
@@ -878,12 +927,8 @@ function createGuard(validator) {
 0 && (module.exports = {
   RenderProp,
   assertType,
-  composable,
   compose,
-  createEffect,
   createGuard,
-  createMemo,
-  createSignal,
   createSlots,
   defineComponent,
   defineSlottedComponent,

package/dist/patterns.d.cts

@@ -1,4 +1,4 @@
-export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, b as assertType, c as composable, d as compose, e as createGuard, f as createSlots, g as defineComponent, h as defineSlottedComponent, i as defineStrictComponent, v as validateProps, j as validators, w as withBoundary, k as withDefaults, l as withProps, m as withWrapper } from './contracts-DDrwxvJ-.cjs';
+export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, b as assertType, c as compose, d as createGuard, e as createSlots, f as defineComponent, g as defineSlottedComponent, h as defineStrictComponent, v as validateProps, i as validators, w as withBoundary, j as withDefaults, k as withProps, l as withWrapper } from './contracts-ey_Qh8ef.cjs';
 
 interface MachineConfig<S extends string, E extends string, C extends Record<string, unknown> = Record<string, unknown>> {
     initial: S;
@@ -88,31 +88,65 @@ interface PersistOptions<T = unknown> {
 }
 declare function persisted<T>(key: string, initial: T, options?: PersistOptions<T>): [() => T, (next: T | ((prev: T) => T)) => void];
 
-interface OptimisticAction<T> {
-    optimisticValue: T;
-    revert: T;
-}
 /**
  * optimistic provides optimistic UI updates that can be reverted on failure.
  * The value updates immediately, then reverts if the async operation fails.
  *
- * Note: concurrent optimistic updates on the same value are inherently
- * ambiguous. If multiple operations are in flight, a failed revert restores
- * the value captured before that specific operation started.
+ * Returns a named object with `value`, `pending`, and `update`.
+ *
+ * Concurrent safety: each operation is tagged with a version counter.
+ * A failing operation only reverts if no newer operation has started since,
+ * preventing stale snapshots from overwriting fresher optimistic state.
+ *
+ * @example
+ * ```ts
+ * const likes = optimistic(42);
+ *
+ * button(
+ *   { on: { click: () => likes.update(likes.value() + 1, () => api.like()) } },
+ *   () => `${likes.value()} ${likes.pending() ? "(saving…)" : ""}`,
+ * );
+ * ```
  */
-declare function optimistic<T>(initialValue: T): [() => T, (optimisticValue: T, asyncAction: () => Promise<T>) => Promise<void>];
+declare function optimistic<T>(initialValue: T): {
+    value: () => T;
+    pending: () => boolean;
+    update: (optimisticValue: T, asyncAction: () => Promise<T>) => Promise<void>;
+};
 /**
  * optimisticList provides optimistic updates for array state.
  *
  * Uses functional updates (setItems(current => ...)) for the success path
  * to avoid losing changes made by concurrent operations. The failure path
- * reverts to a snapshot taken before the operation started.
+ * uses a version guard so stale reverts don't overwrite newer state.
+ *
+ * @example
+ * ```ts
+ * const todos = optimisticList<Todo>([]);
+ *
+ * todos.add(
+ *   { id: tempId(), text: "New" },
+ *   async () => api.createTodo("New"),
+ * );
+ *
+ * div([
+ *   () => todos.pending() ? span("Saving…") : null,
+ *   each(() => todos.items(), (t) => div(t().text), { key: (t) => t.id }),
+ * ]);
+ * ```
  */
 declare function optimisticList<T>(initialValue: T[]): {
     items: () => T[];
+    pending: () => boolean;
+    add: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
+    remove: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
+    update: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `add` instead */
     addOptimistic: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `remove` instead */
     removeOptimistic: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
-    updateOptimistic: (predicate: (item: T) => boolean, update: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `update` instead */
+    updateOptimistic: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
 };
 
 interface TimeTravelReturn<T> {
@@ -151,52 +185,4 @@ declare function globalStore<S extends Record<string, unknown>, A extends Record
     middleware?: Middleware<S>[];
 }): GlobalStore<S, A>;
 
-/**
- * SolidJS-style reactive primitives — standalone APIs that don't require
- * being inside a component. These are thin wrappers around the signal system.
- */
-/**
- * Creates a reactive signal. Equivalent to signal but with SolidJS naming.
- *
- * @param value Initial value
- * @returns Tuple [getter, setter]
- *
- * @example
- * ```ts
- * const [count, setCount] = createSignal(0);
- * console.log(count()); // 0
- * setCount(5);
- * ```
- */
-declare function createSignal<T>(value: T): [() => T, (next: T | ((prev: T) => T)) => void];
-/**
- * Creates a derived/computed reactive value. Equivalent to derived.
- *
- * @param fn Computation function that reads other signals
- * @returns Getter for the computed value
- *
- * @example
- * ```ts
- * const [count] = createSignal(5);
- * const doubled = createMemo(() => count() * 2);
- * console.log(doubled()); // 10
- * ```
- */
-declare function createMemo<T>(fn: () => T): () => T;
-/**
- * Creates a reactive side effect. Equivalent to effect.
- *
- * @param fn Effect function that reads reactive signals
- * @returns Cleanup/teardown function
- *
- * @example
- * ```ts
- * const [count] = createSignal(0);
- * const cleanup = createEffect(() => {
- *   console.log("Count is:", count());
- * });
- * ```
- */
-declare function createEffect(fn: () => void): () => void;
-
-export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type OptimisticAction, type PersistOptions, type Selector, type TimeTravelReturn, createEffect, createMemo, createSignal, globalStore, machine, optimistic, optimisticList, persisted, timeline };
+export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type PersistOptions, type Selector, type TimeTravelReturn, globalStore, machine, optimistic, optimisticList, persisted, timeline };

package/dist/patterns.d.ts

@@ -1,4 +1,4 @@
-export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, b as assertType, c as composable, d as compose, e as createGuard, f as createSlots, g as defineComponent, h as defineSlottedComponent, i as defineStrictComponent, v as validateProps, j as validators, w as withBoundary, k as withDefaults, l as withProps, m as withWrapper } from './contracts-DDrwxvJ-.js';
+export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, b as assertType, c as compose, d as createGuard, e as createSlots, f as defineComponent, g as defineSlottedComponent, h as defineStrictComponent, v as validateProps, i as validators, w as withBoundary, j as withDefaults, k as withProps, l as withWrapper } from './contracts-ey_Qh8ef.js';
 
 interface MachineConfig<S extends string, E extends string, C extends Record<string, unknown> = Record<string, unknown>> {
     initial: S;
@@ -88,31 +88,65 @@ interface PersistOptions<T = unknown> {
 }
 declare function persisted<T>(key: string, initial: T, options?: PersistOptions<T>): [() => T, (next: T | ((prev: T) => T)) => void];
 
-interface OptimisticAction<T> {
-    optimisticValue: T;
-    revert: T;
-}
 /**
  * optimistic provides optimistic UI updates that can be reverted on failure.
  * The value updates immediately, then reverts if the async operation fails.
  *
- * Note: concurrent optimistic updates on the same value are inherently
- * ambiguous. If multiple operations are in flight, a failed revert restores
- * the value captured before that specific operation started.
+ * Returns a named object with `value`, `pending`, and `update`.
+ *
+ * Concurrent safety: each operation is tagged with a version counter.
+ * A failing operation only reverts if no newer operation has started since,
+ * preventing stale snapshots from overwriting fresher optimistic state.
+ *
+ * @example
+ * ```ts
+ * const likes = optimistic(42);
+ *
+ * button(
+ *   { on: { click: () => likes.update(likes.value() + 1, () => api.like()) } },
+ *   () => `${likes.value()} ${likes.pending() ? "(saving…)" : ""}`,
+ * );
+ * ```
  */
-declare function optimistic<T>(initialValue: T): [() => T, (optimisticValue: T, asyncAction: () => Promise<T>) => Promise<void>];
+declare function optimistic<T>(initialValue: T): {
+    value: () => T;
+    pending: () => boolean;
+    update: (optimisticValue: T, asyncAction: () => Promise<T>) => Promise<void>;
+};
 /**
  * optimisticList provides optimistic updates for array state.
  *
  * Uses functional updates (setItems(current => ...)) for the success path
  * to avoid losing changes made by concurrent operations. The failure path
- * reverts to a snapshot taken before the operation started.
+ * uses a version guard so stale reverts don't overwrite newer state.
+ *
+ * @example
+ * ```ts
+ * const todos = optimisticList<Todo>([]);
+ *
+ * todos.add(
+ *   { id: tempId(), text: "New" },
+ *   async () => api.createTodo("New"),
+ * );
+ *
+ * div([
+ *   () => todos.pending() ? span("Saving…") : null,
+ *   each(() => todos.items(), (t) => div(t().text), { key: (t) => t.id }),
+ * ]);
+ * ```
  */
 declare function optimisticList<T>(initialValue: T[]): {
     items: () => T[];
+    pending: () => boolean;
+    add: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
+    remove: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
+    update: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `add` instead */
     addOptimistic: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `remove` instead */
     removeOptimistic: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
-    updateOptimistic: (predicate: (item: T) => boolean, update: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
+    /** @deprecated Use `update` instead */
+    updateOptimistic: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
 };
 
 interface TimeTravelReturn<T> {
@@ -151,52 +185,4 @@ declare function globalStore<S extends Record<string, unknown>, A extends Record
     middleware?: Middleware<S>[];
 }): GlobalStore<S, A>;
 
-/**
- * SolidJS-style reactive primitives — standalone APIs that don't require
- * being inside a component. These are thin wrappers around the signal system.
- */
-/**
- * Creates a reactive signal. Equivalent to signal but with SolidJS naming.
- *
- * @param value Initial value
- * @returns Tuple [getter, setter]
- *
- * @example
- * ```ts
- * const [count, setCount] = createSignal(0);
- * console.log(count()); // 0
- * setCount(5);
- * ```
- */
-declare function createSignal<T>(value: T): [() => T, (next: T | ((prev: T) => T)) => void];
-/**
- * Creates a derived/computed reactive value. Equivalent to derived.
- *
- * @param fn Computation function that reads other signals
- * @returns Getter for the computed value
- *
- * @example
- * ```ts
- * const [count] = createSignal(5);
- * const doubled = createMemo(() => count() * 2);
- * console.log(doubled()); // 10
- * ```
- */
-declare function createMemo<T>(fn: () => T): () => T;
-/**
- * Creates a reactive side effect. Equivalent to effect.
- *
- * @param fn Effect function that reads reactive signals
- * @returns Cleanup/teardown function
- *
- * @example
- * ```ts
- * const [count] = createSignal(0);
- * const cleanup = createEffect(() => {
- *   console.log("Count is:", count());
- * });
- * ```
- */
-declare function createEffect(fn: () => void): () => void;
-
-export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type OptimisticAction, type PersistOptions, type Selector, type TimeTravelReturn, createEffect, createMemo, createSignal, globalStore, machine, optimistic, optimisticList, persisted, timeline };
+export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type PersistOptions, type Selector, type TimeTravelReturn, globalStore, machine, optimistic, optimisticList, persisted, timeline };