storion 0.2.2 → 0.3.0

package/dist/{index-rLf6DusB.js → store-XP2pujaJ.js}

@@ -1,3 +1,34 @@
+const STORION_TYPE = Symbol("STORION");
+function is$1(value, kind) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && value[STORION_TYPE] === kind;
+}
+function isStorion(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && typeof value[STORION_TYPE] === "string";
+}
+function getKind(value) {
+  return value[STORION_TYPE];
+}
+function isSpec(value) {
+  return is$1(value, "store.spec");
+}
+function isContainer(value) {
+  return is$1(value, "container");
+}
+function isStore(value) {
+  return is$1(value, "store");
+}
+function isFocus(value) {
+  return is$1(value, "focus");
+}
+function isStoreContext(value) {
+  return is$1(value, "store.context");
+}
+function isSelectorContext(value) {
+  return is$1(value, "selector.context");
+}
+function isAction(value) {
+  return is$1(value, "store.action");
+}
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
@@ -797,75 +828,6 @@ function currentImpl(value) {
 }
 var immer = new Immer2();
 var produce = immer.produce;
-let globalHooks = {
-  scheduleNotification(notify) {
-    notify();
-  },
-  scheduleEffect(runEffect) {
-    runEffect();
-  }
-};
-function getHooks() {
-  return globalHooks;
-}
-function hasReadHook() {
-  return globalHooks.onRead !== void 0;
-}
-function hasWriteHook() {
-  return globalHooks.onWrite !== void 0;
-}
-function withHooks(hooksOrSetup, fn, onFinish) {
-  const prev = globalHooks;
-  if (typeof hooksOrSetup === "function") {
-    globalHooks = {
-      ...globalHooks,
-      ...hooksOrSetup(prev)
-    };
-  } else {
-    globalHooks = { ...prev, ...hooksOrSetup };
-  }
-  try {
-    return fn();
-  } finally {
-    globalHooks = prev;
-    onFinish == null ? void 0 : onFinish();
-  }
-}
-function trackRead(storeId, prop, value, subscribe) {
-  var _a;
-  const key = `${storeId}.${prop}`;
-  (_a = globalHooks.onRead) == null ? void 0 : _a.call(globalHooks, { key, value, subscribe });
-}
-function trackWrite(storeId, prop, next, prev) {
-  var _a;
-  const key = `${storeId}.${prop}`;
-  (_a = globalHooks.onWrite) == null ? void 0 : _a.call(globalHooks, { key, next, prev });
-}
-function untrack(fn) {
-  return withHooks({ onRead: void 0, onWrite: void 0 }, fn);
-}
-function scheduleNotification(notify, key) {
-  globalHooks.scheduleNotification(notify, key);
-}
-function batch(fn) {
-  const pending = /* @__PURE__ */ new Map();
-  return withHooks(
-    (current2) => ({
-      ...current2,
-      scheduleNotification: (notify, key) => {
-        const actualKey = key ?? notify;
-        pending.set(actualKey, notify);
-      }
-    }),
-    fn,
-    // Flush on finish
-    () => {
-      for (const notify of pending.values()) {
-        notify();
-      }
-    }
-  );
-}
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -1736,7 +1698,7 @@ const isEqual$1 = /* @__PURE__ */ getDefaultExportFromCjs(isEqual_1);
 function strictEqual(a, b) {
   return Object.is(a, b);
 }
-function shallowEqual(a, b) {
+function shallowEqual(a, b, itemEqual = Object.is) {
   if (Object.is(a, b)) return true;
   if (typeof a !== "object" || a === null) return false;
   if (typeof b !== "object" || b === null) return false;
@@ -1745,16 +1707,286 @@ function shallowEqual(a, b) {
   if (keysA.length !== keysB.length) return false;
   for (const key of keysA) {
     if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
-    if (!Object.is(a[key], b[key])) return false;
+    if (!itemEqual(a[key], b[key])) return false;
   }
   return true;
 }
+function shallow2Equal(a, b) {
+  return shallowEqual(a, b, shallowEqual);
+}
+function shallow3Equal(a, b) {
+  return shallowEqual(a, b, shallow2Equal);
+}
 const deepEqual = isEqual$1;
-function resolveEquality(equality) {
-  if (!equality || equality === "strict") return strictEqual;
-  if (equality === "shallow") return shallowEqual;
-  if (equality === "deep") return deepEqual;
-  return equality;
+function resolveEquality(e) {
+  if (!e || e === "strict") return strictEqual;
+  if (e === "shallow") return shallowEqual;
+  if (e === "shallow2") return shallow2Equal;
+  if (e === "shallow3") return shallow3Equal;
+  if (e === "deep") return deepEqual;
+  return e;
+}
+function equality(shorthand) {
+  return resolveEquality(shorthand);
+}
+function getAtPath(obj, segments) {
+  let current2 = obj;
+  for (const key of segments) {
+    if (current2 == null) return current2;
+    current2 = current2[key];
+  }
+  return current2;
+}
+function createFocus(focusCtx, path, options) {
+  const segments = path.split(".");
+  const { fallback, equality: equalityOption } = options ?? {};
+  const equalityFn = resolveEquality(equalityOption);
+  const getter = () => {
+    const state = focusCtx.getState();
+    const value = getAtPath(state, segments);
+    if ((value === null || value === void 0) && fallback) {
+      return fallback();
+    }
+    return value;
+  };
+  const setter = (valueOrReducerOrProduce) => {
+    focusCtx.update((draft) => {
+      let current2 = draft;
+      for (let i = 0; i < segments.length - 1; i++) {
+        const key = segments[i];
+        if (current2[key] == null) {
+          current2[key] = {};
+        }
+        current2 = current2[key];
+      }
+      const lastKey = segments[segments.length - 1];
+      let currentValue = current2[lastKey];
+      if ((currentValue === null || currentValue === void 0) && fallback) {
+        currentValue = fallback();
+        current2[lastKey] = currentValue;
+      }
+      if (typeof valueOrReducerOrProduce === "function") {
+        const fn = valueOrReducerOrProduce;
+        const result = fn(currentValue);
+        if (result !== void 0) {
+          current2[lastKey] = result;
+        }
+      } else {
+        current2[lastKey] = valueOrReducerOrProduce;
+      }
+    });
+  };
+  const on = (listener) => {
+    let prevValue = getter();
+    return focusCtx.subscribe(() => {
+      const nextValue = getter();
+      if (!equalityFn(prevValue, nextValue)) {
+        const prev = prevValue;
+        prevValue = nextValue;
+        listener({ next: nextValue, prev });
+      }
+    });
+  };
+  const to = (relativePath, childOptions) => {
+    const combinedPath = `${path}.${relativePath}`;
+    return createFocus(focusCtx, combinedPath, childOptions);
+  };
+  const focus = [getter, setter];
+  const focusObj = focus;
+  focusObj[STORION_TYPE] = "focus";
+  focusObj.on = on;
+  focusObj.to = to;
+  return focus;
+}
+function createUpdateFn(update) {
+  const updateFn = (updaterOrPartial) => {
+    if (typeof updaterOrPartial === "function") {
+      update(updaterOrPartial);
+    } else {
+      update((draft) => {
+        Object.assign(draft, updaterOrPartial);
+      });
+    }
+  };
+  updateFn.action = (updater) => {
+    return (...args) => {
+      update((draft) => {
+        updater(draft, ...args);
+      });
+    };
+  };
+  return updateFn;
+}
+function createStoreContext(options) {
+  const {
+    spec,
+    resolver,
+    getMutableState,
+    update,
+    subscribe,
+    dirty,
+    reset,
+    // getInstance - reserved for future use
+    onDependency,
+    onDispose,
+    isSetupPhase
+  } = options;
+  const currentLifetime = spec.options.lifetime ?? "keepAlive";
+  const ctx = {
+    [STORION_TYPE]: "store.context",
+    get state() {
+      return getMutableState();
+    },
+    // Implementation handles both StoreSpec and Factory overloads
+    get(specOrFactory) {
+      if (!isSetupPhase()) {
+        throw new Error(
+          `get() can only be called during setup phase. Do not call get() inside actions or async callbacks. Declare all dependencies at the top of your setup function.`
+        );
+      }
+      if (!isSpec(specOrFactory)) {
+        return resolver.get(specOrFactory);
+      }
+      const depSpec = specOrFactory;
+      const depLifetime = depSpec.options.lifetime ?? "keepAlive";
+      if (currentLifetime === "keepAlive" && depLifetime === "autoDispose") {
+        const currentName = spec.options.name ?? "unknown";
+        const depName = depSpec.name ?? "unknown";
+        throw new Error(
+          `Lifetime mismatch: Store "${currentName}" (keepAlive) cannot depend on store "${depName}" (autoDispose). A long-lived store cannot depend on a store that may be disposed. Either change "${currentName}" to autoDispose, or change "${depName}" to keepAlive.`
+        );
+      }
+      const instance = resolver.get(depSpec);
+      onDependency == null ? void 0 : onDependency(instance);
+      const tuple = [instance.state, instance.actions];
+      return Object.assign(tuple, {
+        state: instance.state,
+        actions: instance.actions
+      });
+    },
+    // Implementation handles both StoreSpec and Factory overloads
+    create(specOrFactory) {
+      if (!isSetupPhase()) {
+        throw new Error(
+          `create() can only be called during setup phase. Do not call create() inside actions or async callbacks. Declare all child stores at the top of your setup function.`
+        );
+      }
+      if (!isSpec(specOrFactory)) {
+        const instance2 = specOrFactory(resolver);
+        if (instance2 && typeof instance2.dispose === "function") {
+          onDispose == null ? void 0 : onDispose(instance2.dispose);
+        }
+        return instance2;
+      }
+      const childSpec = specOrFactory;
+      const childLifetime = childSpec.options.lifetime ?? "keepAlive";
+      if (currentLifetime === "keepAlive" && childLifetime === "autoDispose") {
+        const currentName = spec.options.name ?? "unknown";
+        const childName = childSpec.name ?? "unknown";
+        throw new Error(
+          `Lifetime mismatch: Store "${currentName}" (keepAlive) cannot create child store "${childName}" (autoDispose). A long-lived store cannot create a store that may be disposed before it. Either change "${currentName}" to autoDispose, or change "${childName}" to keepAlive.`
+        );
+      }
+      const instance = resolver.create(childSpec);
+      onDispose == null ? void 0 : onDispose(instance.dispose);
+      return instance;
+    },
+    update: createUpdateFn(update),
+    dirty(prop) {
+      return dirty(prop);
+    },
+    reset() {
+      reset();
+    },
+    mixin(mixin, ...args) {
+      if (!isSetupPhase()) {
+        throw new Error(
+          `mixin() can only be called during setup phase. Do not call mixin() inside actions or async callbacks.`
+        );
+      }
+      return mixin(ctx, ...args);
+    },
+    focus(path, options2) {
+      const focusCtx = {
+        getState: getMutableState,
+        update: (updater) => {
+          ctx.update(updater);
+        },
+        subscribe
+      };
+      return createFocus(focusCtx, path, options2);
+    }
+  };
+  return ctx;
+}
+let globalHooks = {
+  scheduleNotification(notify) {
+    notify();
+  },
+  scheduleEffect(runEffect) {
+    runEffect();
+  }
+};
+function getHooks() {
+  return globalHooks;
+}
+function hasReadHook() {
+  return globalHooks.onRead !== void 0;
+}
+function hasWriteHook() {
+  return globalHooks.onWrite !== void 0;
+}
+function withHooks(hooksOrSetup, fn, onFinish) {
+  const prev = globalHooks;
+  if (typeof hooksOrSetup === "function") {
+    globalHooks = {
+      ...globalHooks,
+      ...hooksOrSetup(prev)
+    };
+  } else {
+    globalHooks = { ...prev, ...hooksOrSetup };
+  }
+  try {
+    return fn();
+  } finally {
+    globalHooks = prev;
+    onFinish == null ? void 0 : onFinish();
+  }
+}
+function trackRead(storeId, prop, value, subscribe) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onRead) == null ? void 0 : _a.call(globalHooks, { key, value, subscribe });
+}
+function trackWrite(storeId, prop, next, prev) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onWrite) == null ? void 0 : _a.call(globalHooks, { key, next, prev });
+}
+function untrack(fn) {
+  return withHooks({ onRead: void 0, onWrite: void 0 }, fn);
+}
+function scheduleNotification(notify, key) {
+  globalHooks.scheduleNotification(notify, key);
+}
+function batch(fn) {
+  const pending = /* @__PURE__ */ new Map();
+  return withHooks(
+    (current2) => ({
+      ...current2,
+      scheduleNotification: (notify, key) => {
+        const actualKey = key ?? notify;
+        pending.set(actualKey, notify);
+      }
+    }),
+    fn,
+    // Flush on finish
+    () => {
+      for (const notify of pending.values()) {
+        notify();
+      }
+    }
+  );
 }
 let specIdCounter = 0;
 function generateSpecName() {
@@ -1764,6 +1996,19 @@ let instanceIdCounter = 0;
 function generateStoreId(specName) {
   return `${specName}:${++instanceIdCounter}`;
 }
+const ORIGINAL_FN = Symbol.for("storion.originalFn");
+function wrapFn(originalFn, createWrapper) {
+  const wrapper = createWrapper(originalFn);
+  wrapper[ORIGINAL_FN] = originalFn;
+  return wrapper;
+}
+function unwrapFn(fn) {
+  const original = fn[ORIGINAL_FN];
+  return original ?? fn;
+}
+function isWrappedFn(fn) {
+  return ORIGINAL_FN in fn;
+}
 function emitter(initialListeners) {
   const listeners = /* @__PURE__ */ new Set([]);
   let settledPayload;
@@ -1911,21 +2156,80 @@ function emitter(initialListeners) {
     }
   };
 }
+function collection(createItem, initialItems) {
+  const map = /* @__PURE__ */ new Map([]);
+  return {
+    with(key, callback) {
+      if (map.has(key)) {
+        callback(map.get(key));
+      }
+      return this;
+    },
+    /** Check if key exists (does NOT create item) */
+    has(key) {
+      return map.has(key);
+    },
+    /** Get item by key, creating it if it doesn't exist */
+    get(key) {
+      if (!map.has(key)) {
+        map.set(key, createItem(key));
+      }
+      return map.get(key);
+    },
+    /** Explicitly set an item */
+    set(key, value) {
+      map.set(key, value);
+      return this;
+    },
+    /** Number of items in the collection */
+    get size() {
+      return map.size;
+    },
+    /** Remove all items */
+    clear() {
+      map.clear();
+      return this;
+    },
+    /** Remove a specific item */
+    delete(key) {
+      map.delete(key);
+      return this;
+    },
+    /** Iterate over keys */
+    keys() {
+      return map.keys();
+    },
+    /** Iterate over values */
+    values() {
+      return map.values();
+    },
+    /** Iterate over [key, value] pairs */
+    entries() {
+      return map.entries();
+    }
+  };
+}
 function store(options) {
   const name = options.name ?? generateSpecName();
-  return {
-    name,
-    options
+  const spec = function(resolver) {
+    return createStoreInstance(spec, resolver, {});
   };
+  Object.defineProperties(spec, {
+    [STORION_TYPE]: { value: "store.spec", enumerable: false },
+    name: { value: name, enumerable: true, writable: false },
+    options: { value: options, enumerable: true, writable: false }
+  });
+  return spec;
 }
 function createStoreInstance(spec, resolver, instanceOptions = {}) {
+  var _a;
   const options = spec.options;
   const storeId = generateStoreId(spec.name);
   let disposed = false;
   let currentState = { ...options.state };
   let initialState = currentState;
   const isAutoDispose = options.lifetime === "autoDispose";
-  const gracePeriodMs = instanceOptions.gracePeriodMs ?? 100;
+  const gracePeriodMs = ((_a = instanceOptions.autoDispose) == null ? void 0 : _a.gracePeriodMs) ?? 100;
   let refCount = 0;
   let disposeTimeout = null;
   const incrementRef = () => {
@@ -1942,39 +2246,26 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
     if (!isAutoDispose || isSetupPhase) {
       return;
     }
+    disposeTimeout && clearTimeout(disposeTimeout);
     refCount--;
-    if (refCount <= 0 && instanceOptions.onUnused) {
+    if (refCount <= 0) {
       disposeTimeout = setTimeout(() => {
         disposeTimeout = null;
-        if (refCount <= 0 && !disposed) {
-          instanceOptions.onUnused();
+        if (refCount <= 0) {
+          instance == null ? void 0 : instance.dispose();
         }
       }, gracePeriodMs);
     }
   };
   const changeEmitter = emitter();
   const disposeEmitter = emitter();
-  const propertyEmitters = /* @__PURE__ */ new Map();
-  const getPropertyEmitter = (key) => {
-    let em = propertyEmitters.get(key);
-    if (!em) {
-      em = emitter();
-      propertyEmitters.set(key, em);
-    }
-    return em;
-  };
+  const propertyEmitters = collection(() => emitter());
   const actionInvocations = /* @__PURE__ */ new Map();
   const actionNthCounters = /* @__PURE__ */ new Map();
-  const actionEmitters = /* @__PURE__ */ new Map();
+  const actionEmitters = collection(
+    () => emitter()
+  );
   const wildcardActionEmitter = emitter();
-  const getActionEmitter = (actionName) => {
-    let em = actionEmitters.get(actionName);
-    if (!em) {
-      em = emitter();
-      actionEmitters.set(actionName, em);
-    }
-    return em;
-  };
   const disposeEffectsEmitter = emitter();
   const equalityOption = options.equality;
   const propertyEquality = /* @__PURE__ */ new Map();
@@ -1998,45 +2289,21 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   }
   const getEquality = (key) => propertyEquality.get(key) ?? defaultEquality ?? strictEqual;
   const isEqual2 = hasCustomEquality ? (key, a, b) => getEquality(key)(a, b) : (_key, a, b) => a === b;
+  let isSetupPhase = true;
   function handlePropertyChange(key, oldValue, newValue) {
-    const propEmitter = propertyEmitters.get(key);
-    if (propEmitter) {
-      propEmitter.emit({ newValue, oldValue });
+    if (isSetupPhase) {
+      return;
     }
+    propertyEmitters.with(
+      key,
+      (em) => em.emit({ newValue, oldValue })
+    );
     scheduleNotification(() => {
       changeEmitter.emit();
     });
   }
   let instance = null;
   const getInst = () => instance;
-  function handleActionDispatch(actionName, args) {
-    const name = actionName;
-    const nth = (actionNthCounters.get(name) ?? 0) + 1;
-    actionNthCounters.set(name, nth);
-    const prev = actionInvocations.get(name);
-    const next = Object.freeze({
-      name: actionName,
-      args,
-      nth
-    });
-    actionInvocations.set(
-      name,
-      next
-    );
-    const actionEmitter = actionEmitters.get(name);
-    if (actionEmitter) {
-      actionEmitter.emit({
-        next,
-        prev
-      });
-    }
-    if (wildcardActionEmitter.size > 0) {
-      wildcardActionEmitter.emit({
-        next,
-        prev
-      });
-    }
-  }
   function getActionLastInvocation(actionName) {
     const propKey = `@${String(actionName)}`;
     const invocation = actionInvocations.get(String(actionName));
@@ -2048,6 +2315,7 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   }
   let instanceActions = {};
   instance = {
+    [STORION_TYPE]: "store",
     id: storeId,
     spec,
     deps: [],
@@ -2077,15 +2345,14 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
       }
       if (key.startsWith("@")) {
         const actionName = key.slice(1);
-        const actionEmitter = getActionEmitter(actionName);
-        const unsub2 = actionEmitter.on(propListener);
+        const unsub2 = actionEmitters.get(actionName).on(propListener);
         return () => {
           unsub2();
           decrementRef();
         };
       }
       const propKey = listenerOrPropKey;
-      const propEmitter = getPropertyEmitter(propKey);
+      const propEmitter = propertyEmitters.get(propKey);
       const unsub = propEmitter.on(({ newValue, oldValue }) => {
         propListener({ next: newValue, prev: oldValue });
       });
@@ -2099,11 +2366,9 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
       const key = propKey;
       if (key.startsWith("@")) {
         const actionName = key.slice(1);
-        const actionEmitter = getActionEmitter(actionName);
-        return actionEmitter.on(listener);
+        return actionEmitters.get(actionName).on(listener);
       }
-      const propEmitter = getPropertyEmitter(propKey);
-      return propEmitter.on(listener);
+      return propertyEmitters.get(propKey).on(listener);
     },
     dispose() {
       if (disposed) return;
@@ -2203,97 +2468,76 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   }
   const mutableState = createReactiveState(true);
   const readonlyState = createReactiveState(false);
-  let isSetupPhase = true;
   const deps = /* @__PURE__ */ new Set();
-  const currentLifetime = options.lifetime ?? "keepAlive";
-  const setupContext = {
-    state: mutableState,
-    resolve(depSpec) {
-      if (!isSetupPhase) {
-        throw new Error(
-          `get() can only be called during setup phase. Do not call get() inside actions or async callbacks. Declare all dependencies at the top of your setup function.`
-        );
-      }
-      const depLifetime = depSpec.options.lifetime ?? "keepAlive";
-      if (currentLifetime === "keepAlive" && depLifetime === "autoDispose") {
-        const currentName = options.name ?? "unknown";
-        const depName = depSpec.name ?? "unknown";
-        throw new Error(
-          `Lifetime mismatch: Store "${currentName}" (keepAlive) cannot depend on store "${depName}" (autoDispose). A long-lived store cannot depend on a store that may be disposed. Either change "${currentName}" to autoDispose, or change "${depName}" to keepAlive.`
-        );
-      }
-      const instance2 = resolver.get(depSpec);
-      deps.add(instance2);
-      return [instance2.state, instance2.actions];
-    },
-    update(updaterOrPartial) {
-      let nextState = currentState;
-      if (typeof updaterOrPartial === "function") {
-        const updater = updaterOrPartial;
-        nextState = produce(currentState, updater);
-      } else {
-        nextState = produce(currentState, (draft) => {
-          Object.assign(draft, updaterOrPartial);
-        });
-      }
-      if (nextState === currentState) return;
-      const prevState = currentState;
-      const changedProps = [];
-      if (!hasCustomEquality) {
-        for (const key of Object.keys(nextState)) {
-          if (prevState[key] !== nextState[key]) {
-            changedProps.push({
-              key,
-              oldValue: prevState[key],
-              newValue: nextState[key]
-            });
-          }
+  function updateState(updaterOrPartial) {
+    let nextState = currentState;
+    if (typeof updaterOrPartial === "function") {
+      const updater = updaterOrPartial;
+      nextState = produce(currentState, updater);
+    } else {
+      nextState = produce(currentState, (draft) => {
+        Object.assign(draft, updaterOrPartial);
+      });
+    }
+    if (nextState === currentState) return;
+    const prevState = currentState;
+    const changedProps = [];
+    if (!hasCustomEquality) {
+      for (const key of Object.keys(nextState)) {
+        if (prevState[key] !== nextState[key]) {
+          changedProps.push({
+            key,
+            oldValue: prevState[key],
+            newValue: nextState[key]
+          });
         }
-        if (changedProps.length > 0) {
-          currentState = nextState;
+      }
+      if (changedProps.length > 0) {
+        currentState = nextState;
+        batch(() => {
           for (const { key, oldValue, newValue } of changedProps) {
             handlePropertyChange(key, oldValue, newValue);
           }
-        }
-        return;
+        });
       }
-      const stableState = { ...nextState };
-      for (const key of Object.keys(nextState)) {
-        if (prevState[key] !== nextState[key]) {
-          const equality = getEquality(key);
-          if (equality(prevState[key], nextState[key])) {
-            stableState[key] = prevState[key];
-          } else {
-            changedProps.push({
-              key,
-              oldValue: prevState[key],
-              newValue: nextState[key]
-            });
-          }
+      return;
+    }
+    const stableState = { ...nextState };
+    for (const key of Object.keys(nextState)) {
+      if (prevState[key] !== nextState[key]) {
+        const equality2 = getEquality(key);
+        if (equality2(prevState[key], nextState[key])) {
+          stableState[key] = prevState[key];
+        } else {
+          changedProps.push({
+            key,
+            oldValue: prevState[key],
+            newValue: nextState[key]
+          });
         }
       }
-      if (changedProps.length > 0) {
-        currentState = stableState;
+    }
+    if (changedProps.length > 0) {
+      currentState = stableState;
+      batch(() => {
         for (const { key, oldValue, newValue } of changedProps) {
           handlePropertyChange(key, oldValue, newValue);
         }
-      }
-    },
-    dirty(prop) {
-      return instance.dirty(prop);
-    },
-    reset() {
-      instance.reset();
-    },
-    use(mixin, ...args) {
-      if (!isSetupPhase) {
-        throw new Error(
-          `use() can only be called during setup phase. Do not call use() inside actions or async callbacks.`
-        );
-      }
-      return mixin(setupContext, ...args);
+      });
     }
-  };
+  }
+  const setupContext = createStoreContext({
+    spec,
+    resolver,
+    getMutableState: () => mutableState,
+    update: updateState,
+    subscribe: (listener) => changeEmitter.on(listener),
+    dirty: (prop) => instance.dirty(prop),
+    reset: () => instance.reset(),
+    onDependency: (depInstance) => deps.add(depInstance),
+    onDispose: (callback) => disposeEmitter.on(callback),
+    isSetupPhase: () => isSetupPhase
+  });
   let actions;
   const scheduledEffects = [];
   try {
@@ -2321,541 +2565,94 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   deps.clear();
   const wrappedActions = {};
   for (const [name, action] of Object.entries(actions)) {
-    const wrappedAction = (...args) => {
-      if (disposed) {
-        throw new Error(`Cannot call action on disposed store: ${storeId}`);
-      }
-      handleActionDispatch(
-        name,
-        args
-      );
-      if (options.onDispatch) {
-        const invocation = actionInvocations.get(name);
-        if (invocation) {
-          options.onDispatch(invocation);
-        }
-      }
-      try {
-        return action(...args);
-      } catch (error) {
-        if (options.onError) {
-          options.onError(error);
-        }
-        throw error;
-      }
-    };
-    wrappedAction.last = () => getActionLastInvocation(name);
-    wrappedActions[name] = wrappedAction;
-  }
-  instanceActions = wrappedActions;
-  return instance;
-}
-function container(options = {}) {
-  const { middleware = [] } = options;
-  const instancesBySpec = /* @__PURE__ */ new Map();
-  const instancesById = /* @__PURE__ */ new Map();
-  const creationOrder = [];
-  const createEmitter = emitter();
-  const disposeEmitter = emitter();
-  const creating = /* @__PURE__ */ new Set();
-  const resolver = {
-    get(specOrId) {
-      if (typeof specOrId === "string") {
-        return instancesById.get(specOrId);
-      }
-      return containerApi.get(specOrId);
-    },
-    has(spec) {
-      return instancesBySpec.has(spec);
-    }
-  };
-  function createInstance(spec) {
-    const instanceOptions = {};
-    if (spec.options.lifetime === "autoDispose") {
-      instanceOptions.onUnused = () => {
-        containerApi.dispose(spec);
-      };
-    }
-    return createStoreInstance(spec, resolver, instanceOptions);
-  }
-  function buildMiddlewareChain() {
-    let chain = (_spec, next) => next(_spec);
-    for (let i = middleware.length - 1; i >= 0; i--) {
-      const currentMiddleware = middleware[i];
-      const nextInChain = chain;
-      chain = (spec, next) => currentMiddleware(spec, (s) => nextInChain(s, next));
-    }
-    return (spec) => chain(spec, createInstance);
-  }
-  const createWithMiddleware = buildMiddlewareChain();
-  function getOrCreateInstance(spec) {
-    var _a;
-    let instance = instancesBySpec.get(spec);
-    if (instance) {
-      return instance;
-    }
-    if (creating.has(spec)) {
-      const name = spec.name ?? "unknown";
+    if (typeof action !== "function") {
       throw new Error(
-        `Circular dependency detected: "${name}" is being created while it's already in the creation stack.`
+        `Action "${name}" must be a function, got ${typeof action}. If using focus(), destructure it and return the getter/setter separately: const [get, set] = focus("path"); return { get, set };`
       );
     }
-    creating.add(spec);
-    try {
-      instance = untrack(() => createWithMiddleware(spec));
-      instancesBySpec.set(spec, instance);
-      instancesById.set(instance.id, instance);
-      creationOrder.push(spec);
-      (_a = instance.onDispose) == null ? void 0 : _a.call(instance, () => {
-        instancesBySpec.delete(spec);
-        instancesById.delete(instance.id);
-        const index = creationOrder.indexOf(spec);
-        if (index !== -1) {
-          creationOrder.splice(index, 1);
+    const wrappedAction = wrapFn(action, (originalAction) => {
+      const wrapper = (...args) => {
+        if (disposed) {
+          throw new Error(`Cannot call action on disposed store: ${storeId}`);
         }
-      });
-      createEmitter.emit(instance);
-      return instance;
-    } finally {
-      creating.delete(spec);
-    }
-  }
-  const containerApi = {
-    get(specOrId) {
-      if (typeof specOrId === "string") {
-        return instancesById.get(specOrId);
-      }
-      return getOrCreateInstance(specOrId);
-    },
-    has(spec) {
-      return instancesBySpec.has(spec);
-    },
-    clear() {
-      const specs = [...creationOrder].reverse();
-      for (const spec of specs) {
-        const instance = instancesBySpec.get(spec);
-        if (instance) {
-          disposeEmitter.emit(instance);
-          instance.dispose();
-          instancesById.delete(instance.id);
-        }
-      }
-      instancesBySpec.clear();
-      creationOrder.length = 0;
-    },
-    dispose(spec) {
-      const instance = instancesBySpec.get(spec);
-      if (!instance) return false;
-      disposeEmitter.emit(instance);
-      instance.dispose();
-      instancesBySpec.delete(spec);
-      instancesById.delete(instance.id);
-      const index = creationOrder.indexOf(spec);
-      if (index !== -1) {
-        creationOrder.splice(index, 1);
-      }
-      return true;
-    },
-    onCreate(listener) {
-      return createEmitter.on(listener);
-    },
-    onDispose(listener) {
-      return disposeEmitter.on(listener);
-    }
-  };
-  return containerApi;
-}
-let pickIdCounter = 0;
-function pick(selector, equality) {
-  var _a;
-  const parentHooks = getHooks();
-  if (!parentHooks.onRead) {
-    throw new Error(
-      "pick() must be called inside an effect or useStore selector. It requires an active hooks.onRead context."
-    );
-  }
-  const equalityFn = resolveEquality(equality);
-  const currentReads = [];
-  const evaluate = () => {
-    currentReads.length = 0;
-    const value = withHooks(
-      {
-        onRead: (event) => {
-          currentReads.push(event);
-        }
-      },
-      selector
-    );
-    return value;
-  };
-  let currentValue = evaluate();
-  if (!currentReads.length) {
-    return currentValue;
-  }
-  const pickKey = `pick:${++pickIdCounter}`;
-  const subscribe = (listener) => {
-    const onCleanup = emitter();
-    const setupSubscriptions = () => {
-      for (const read of currentReads) {
-        const unsub = read.subscribe(handleChange);
-        onCleanup.on(unsub);
-      }
-    };
-    const clearSubscriptions = () => {
-      onCleanup.emitAndClear();
-    };
-    const handleChange = () => {
-      try {
-        const prevValue = currentValue;
-        clearSubscriptions();
-        currentValue = evaluate();
-        setupSubscriptions();
-        if (!equalityFn(prevValue, currentValue)) {
-          listener();
-        }
-      } catch (error) {
-        clearSubscriptions();
-        throw error;
-      }
-    };
-    setupSubscriptions();
-    return clearSubscriptions;
-  };
-  (_a = parentHooks.onRead) == null ? void 0 : _a.call(parentHooks, {
-    key: pickKey,
-    value: currentValue,
-    subscribe
-  });
-  return currentValue;
-}
-function createEffectContext(nth, isStale) {
-  let cleanupEmitter = null;
-  let abortController = null;
-  const runCleanups = () => {
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-    if (cleanupEmitter && cleanupEmitter.size > 0) {
-      cleanupEmitter.emitAndClearLifo();
-    }
-  };
-  const context = {
-    nth,
-    get signal() {
-      if (!abortController) {
-        abortController = new AbortController();
-      }
-      return abortController.signal;
-    },
-    onCleanup(listener) {
-      if (!cleanupEmitter) {
-        cleanupEmitter = emitter();
-      }
-      return cleanupEmitter.on(listener);
-    },
-    safe(promiseOrCallback) {
-      if (promiseOrCallback instanceof Promise) {
-        return new Promise((resolve, reject) => {
-          promiseOrCallback.then(
-            (value) => {
-              if (!isStale()) {
-                resolve(value);
-              }
-            },
-            (error) => {
-              if (!isStale()) {
-                reject(error);
-              }
-            }
-          );
+        const actionNameKey = name;
+        const nthKey = name;
+        const nth = (actionNthCounters.get(nthKey) ?? 0) + 1;
+        actionNthCounters.set(nthKey, nth);
+        const prev = actionInvocations.get(nthKey);
+        const next = Object.freeze({
+          name: actionNameKey,
+          args,
+          nth,
+          timestamp: Date.now()
         });
-      }
-      return (...args) => {
-        if (!isStale()) {
-          return promiseOrCallback(...args);
+        actionInvocations.set(nthKey, next);
+        const actionEmitter = actionEmitters.get(nthKey);
+        if (actionEmitter.size > 0) {
+          actionEmitter.emit({
+            next,
+            prev
+          });
         }
-        return void 0;
-      };
-    }
-  };
-  return Object.assign(context, { _runCleanups: runCleanups });
-}
-function resolveErrorStrategy(effectOptions) {
-  return (effectOptions == null ? void 0 : effectOptions.onError) ?? "keepAlive";
-}
-function getRetryDelay(config, attempt) {
-  if (typeof config.delay === "function") {
-    return config.delay(attempt);
-  }
-  return config.delay ?? 100 * Math.pow(2, attempt);
-}
-function effect(fn, options) {
-  let currentContext = null;
-  let subscriptionEmitter = null;
-  let isStarted = false;
-  let isRunning = false;
-  let isDisposed = false;
-  let runGeneration = 0;
-  let retryCount = 0;
-  let retryTimeout = null;
-  let errorStrategy = "keepAlive";
-  let onErrorCallback = null;
-  let prevTrackedDeps = /* @__PURE__ */ new Map();
-  let prevSubscriptionEmitter = null;
-  let trackedDeps = /* @__PURE__ */ new Map();
-  const writtenProps = /* @__PURE__ */ new Set();
-  let newTrackedDeps = null;
-  const getSubscriptionEmitter = () => {
-    if (!subscriptionEmitter) {
-      subscriptionEmitter = emitter();
-    }
-    return subscriptionEmitter;
-  };
-  const clearSubscriptions = () => {
-    if (subscriptionEmitter && subscriptionEmitter.size > 0) {
-      subscriptionEmitter.emitAndClear();
-    }
-  };
-  const areDepsChanged = (prev, next) => {
-    if (prev.size !== next.size) return true;
-    for (const key of next.keys()) {
-      if (!prev.has(key)) return true;
-    }
-    return false;
-  };
-  const subscribeToTrackedDeps = () => {
-    for (const [key, dep] of trackedDeps) {
-      if (writtenProps.has(key)) continue;
-      const unsub = dep.subscribe(() => {
-        scheduleNotification(execute, fn);
-      });
-      getSubscriptionEmitter().on(unsub);
-    }
-  };
-  const handleError = (error) => {
-    onErrorCallback == null ? void 0 : onErrorCallback(error);
-    if (errorStrategy === "failFast") {
-      throw error;
-    }
-    if (errorStrategy === "keepAlive") {
-      console.error("Effect error (keepAlive):", error);
-      if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-        trackedDeps = new Map(prevTrackedDeps);
-        subscriptionEmitter = prevSubscriptionEmitter;
-        prevSubscriptionEmitter = null;
-        return;
-      }
-      if (newTrackedDeps && newTrackedDeps.size > 0) {
-        trackedDeps = newTrackedDeps;
-      }
-      subscribeToTrackedDeps();
-      return;
-    }
-    if (typeof errorStrategy === "function") {
-      const retry = () => {
-        retryCount++;
-        execute();
-      };
-      errorStrategy({ error, retry, retryCount });
-      return;
-    }
-    const retryConfig = errorStrategy;
-    if (retryCount < retryConfig.maxRetries) {
-      const delay = getRetryDelay(retryConfig, retryCount);
-      retryCount++;
-      retryTimeout = setTimeout(() => {
-        retryTimeout = null;
-        execute();
-      }, delay);
-    } else {
-      console.error(
-        `Effect failed after ${retryConfig.maxRetries} retries:`,
-        error
-      );
-    }
-  };
-  let cachedHooks = null;
-  const getTrackingHooks = (current2) => {
-    if (!cachedHooks) {
-      cachedHooks = {
-        ...current2,
-        onRead: (event) => {
-          var _a;
-          (_a = current2.onRead) == null ? void 0 : _a.call(current2, event);
-          if (!newTrackedDeps.has(event.key)) {
-            newTrackedDeps.set(event.key, {
-              key: event.key,
-              value: event.value,
-              subscribe: event.subscribe
+        if (options.onDispatch) {
+          options.onDispatch(next);
+        }
+        try {
+          const result = originalAction(...args);
+          if (wildcardActionEmitter.size > 0) {
+            wildcardActionEmitter.emit({
+              next,
+              prev
             });
           }
-        },
-        onWrite: (event) => {
-          var _a;
-          (_a = current2.onWrite) == null ? void 0 : _a.call(current2, event);
-          writtenProps.add(event.key);
-        },
-        scheduleNotification: current2.scheduleNotification,
-        scheduleEffect: current2.scheduleEffect
-      };
-    }
-    return cachedHooks;
-  };
-  const execute = () => {
-    if (isDisposed || isRunning) return;
-    isRunning = true;
-    const currentGeneration = ++runGeneration;
-    try {
-      currentContext == null ? void 0 : currentContext._runCleanups();
-      currentContext = null;
-      if (subscriptionEmitter && subscriptionEmitter.size > 0) {
-        prevTrackedDeps = new Map(trackedDeps);
-        prevSubscriptionEmitter = subscriptionEmitter;
-        subscriptionEmitter = null;
-      }
-      newTrackedDeps = /* @__PURE__ */ new Map();
-      writtenProps.clear();
-      const isStale = () => isDisposed || runGeneration !== currentGeneration;
-      let lazyContext = null;
-      const getOrCreateContext = () => {
-        if (!lazyContext) {
-          lazyContext = createEffectContext(currentGeneration, isStale);
+          return result;
+        } catch (error) {
+          if (wildcardActionEmitter.size > 0) {
+            wildcardActionEmitter.emit({
+              next,
+              prev
+            });
+          }
+          if (options.onError) {
+            options.onError(error);
+          }
+          throw error;
         }
-        return lazyContext;
       };
-      const lazyContextProxy = new Proxy({}, {
-        get(_, prop) {
-          return getOrCreateContext()[prop];
-        }
-      });
-      withHooks(getTrackingHooks, () => {
-        const result = fn(lazyContextProxy);
-        if (result !== null && result !== void 0 && typeof result.then === "function") {
-          throw new Error(
-            "Effect function must be synchronous. Use ctx.safe(promise) for async operations instead of returning a Promise."
-          );
-        }
-      });
-      currentContext = lazyContext;
-      retryCount = 0;
-      const depsChanged = areDepsChanged(trackedDeps, newTrackedDeps);
-      if (depsChanged) {
-        if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-          prevSubscriptionEmitter.emitAndClear();
-        }
-        trackedDeps = newTrackedDeps;
-        subscribeToTrackedDeps();
-      } else {
-        if (prevSubscriptionEmitter) {
-          subscriptionEmitter = prevSubscriptionEmitter;
-        }
-      }
-      prevTrackedDeps.clear();
-      prevSubscriptionEmitter = null;
-    } catch (error) {
-      handleError(error);
-    } finally {
-      isRunning = false;
-    }
-  };
-  const dispose = () => {
-    if (isDisposed) return;
-    isDisposed = true;
-    runGeneration++;
-    if (retryTimeout) {
-      clearTimeout(retryTimeout);
-      retryTimeout = null;
-    }
-    currentContext == null ? void 0 : currentContext._runCleanups();
-    currentContext = null;
-    clearSubscriptions();
-    if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-      prevSubscriptionEmitter.emitAndClear();
-    }
-  };
-  const start = (runOptions) => {
-    if (isStarted) return;
-    isStarted = true;
-    errorStrategy = resolveErrorStrategy(options);
-    onErrorCallback = (runOptions == null ? void 0 : runOptions.onError) ?? null;
-    execute();
-  };
-  getHooks().scheduleEffect((runOptions) => {
-    start(runOptions);
-    return dispose;
-  });
-  return dispose;
-}
-function patternToPredicate(pattern) {
-  if (pattern instanceof RegExp) {
-    return (name) => pattern.test(name);
-  }
-  const startsWithWildcard = pattern.startsWith("*");
-  const endsWithWildcard = pattern.endsWith("*");
-  if (startsWithWildcard && endsWithWildcard) {
-    const substr = pattern.slice(1, -1);
-    return (name) => name.includes(substr);
-  }
-  if (startsWithWildcard) {
-    const suffix = pattern.slice(1);
-    return (name) => name.endsWith(suffix);
-  }
-  if (endsWithWildcard) {
-    const prefix = pattern.slice(0, -1);
-    return (name) => name.startsWith(prefix);
-  }
-  return (name) => name === pattern;
-}
-function patternsToPredicate(patterns) {
-  if (Array.isArray(patterns)) {
-    const predicates = patterns.map(patternToPredicate);
-    return (spec) => predicates.some((p) => p(spec.name));
-  }
-  const predicate = patternToPredicate(patterns);
-  return (spec) => predicate(spec.name);
-}
-function compose(...middlewares) {
-  if (middlewares.length === 0) {
-    return (spec, next) => next(spec);
-  }
-  if (middlewares.length === 1) {
-    return middlewares[0];
+      wrapper.last = () => getActionLastInvocation(name);
+      return wrapper;
+    });
+    wrappedActions[name] = wrappedAction;
   }
-  return (spec, next) => {
-    let chain = next;
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-      const middleware = middlewares[i];
-      const prevChain = chain;
-      chain = (s) => middleware(s, prevChain);
-    }
-    return chain(spec);
-  };
-}
-function applyFor(predicateOrPatterns, middleware) {
-  const predicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
-  const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
-  return (spec, next) => {
-    if (predicate(spec)) {
-      return composedMiddleware(spec, next);
-    }
-    return next(spec);
-  };
-}
-function applyExcept(predicateOrPatterns, middleware) {
-  const matchPredicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
-  const invertedPredicate = (spec) => !matchPredicate(spec);
-  return applyFor(invertedPredicate, middleware);
+  instanceActions = wrappedActions;
+  return instance;
 }
 export {
-  applyFor as a,
-  batch as b,
-  container as c,
-  applyExcept as d,
-  effect as e,
-  compose as f,
-  pick as p,
+  STORION_TYPE as S,
+  is$1 as a,
+  isStorion as b,
+  createStoreInstance as c,
+  isContainer as d,
+  emitter as e,
+  isStore as f,
+  getKind as g,
+  isFocus as h,
+  isSpec as i,
+  isAction as j,
+  isStoreContext as k,
+  isSelectorContext as l,
+  batch as m,
+  equality as n,
+  shallowEqual as o,
+  deepEqual as p,
+  strictEqual as q,
+  resolveEquality as r,
   store as s,
+  wrapFn as t,
   untrack as u,
-  withHooks as w
+  unwrapFn as v,
+  withHooks as w,
+  isWrappedFn as x,
+  getHooks as y,
+  scheduleNotification as z
 };