@okyrychenko-dev/react-action-guard 1.0.5 → 2.0.0

package/dist/index.cjs

@@ -1,472 +1,505 @@
 'use strict';
 
 var reactZustandToolkit = require('@okyrychenko-dev/react-zustand-toolkit');
-var zustand = require('zustand');
-require('zustand/react/shallow');
-var jsxRuntime = require('react/jsx-runtime');
-var shallow = require('zustand/shallow');
+var typeUtils = require('@okyrychenko-dev/type-utils');
 var middleware = require('zustand/middleware');
+var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
+var shallow = require('zustand/shallow');
 
 // src/context/UIBlockingContext.tsx
 
-// src/store/uiBlockingStore.constants.ts
+// src/store/scope/scope.constants.ts
 var DEFAULT_SCOPE = "global";
+var normalizedScopeCache = /* @__PURE__ */ new Map();
+var NORMALIZED_SCOPE_CACHE_MAX_SIZE = 256;
+function getNormalizedScopeCacheKey(scopes) {
+  return JSON.stringify(scopes);
+}
+function refreshNormalizedScopeCacheEntry(cacheKey, scopes) {
+  normalizedScopeCache.delete(cacheKey);
+  normalizedScopeCache.set(cacheKey, scopes);
+  return scopes;
+}
+function evictOldestNormalizedScopeCacheEntry() {
+  for (const cacheKey of normalizedScopeCache.keys()) {
+    normalizedScopeCache.delete(cacheKey);
+    break;
+  }
+}
+function getCachedNormalizedScope(scopes) {
+  const normalizedScope = Object.freeze([...new Set(scopes)].sort());
+  const cacheKey = getNormalizedScopeCacheKey(normalizedScope);
+  const cachedScope = normalizedScopeCache.get(cacheKey);
+  if (typeUtils.isDefined(cachedScope)) {
+    return refreshNormalizedScopeCacheEntry(cacheKey, cachedScope);
+  }
+  normalizedScopeCache.set(cacheKey, normalizedScope);
+  if (normalizedScopeCache.size > NORMALIZED_SCOPE_CACHE_MAX_SIZE) {
+    evictOldestNormalizedScopeCacheEntry();
+  }
+  return normalizedScope;
+}
+function normalizeScope(scope) {
+  if (typeUtils.isUndefined(scope)) {
+    return getCachedNormalizedScope([DEFAULT_SCOPE]);
+  }
+  if (typeUtils.isString(scope)) {
+    return getCachedNormalizedScope([scope]);
+  }
+  return getCachedNormalizedScope(scope);
+}
+function resolveScope(explicitScope, inheritedScope) {
+  if (typeUtils.isUndefined(explicitScope) || typeUtils.isReadonlyArray(explicitScope) && !typeUtils.isNonEmptyArray(explicitScope)) {
+    return inheritedScope;
+  }
+  return explicitScope;
+}
+function matchesObservedScopes(blockerScope, observedScopes) {
+  if (!typeUtils.isNonEmptyArray(observedScopes)) {
+    return false;
+  }
+  if (typeUtils.isString(blockerScope)) {
+    return blockerScope === DEFAULT_SCOPE || observedScopes.includes(blockerScope);
+  }
+  return blockerScope.includes(DEFAULT_SCOPE) || observedScopes.some((scope) => blockerScope.includes(scope));
+}
+function scopeAffectsObservation(blockerScope, observedScope) {
+  return matchesObservedScopes(blockerScope, normalizeScope(observedScope));
+}
+function createScopeObservationMatcher(observedScope) {
+  const observedScopes = normalizeScope(observedScope);
+  return (blockerScope) => matchesObservedScopes(blockerScope, observedScopes);
+}
+function scopeMatchesTarget(blockerScope, targetScope) {
+  const blockerScopes = normalizeScope(blockerScope);
+  if (blockerScopes.includes(DEFAULT_SCOPE)) {
+    return false;
+  }
+  const targetScopes = normalizeScope(targetScope);
+  return targetScopes.some((scope) => blockerScopes.includes(scope));
+}
+
+// src/store/blockingInfo/blockingInfo.utils.ts
+function sameScope(first, second) {
+  if (first === second) {
+    return true;
+  }
+  if (typeUtils.isString(first) || typeUtils.isString(second)) {
+    return false;
+  }
+  return first.length === second.length && first.every((scope, index) => scope === second[index]);
+}
+function sameBlocker(first, second) {
+  if (first === second) {
+    return true;
+  }
+  const { id, scope, reason, priority, timestamp, timeout, onTimeout } = first;
+  const {
+    id: previousId,
+    scope: previousScope,
+    reason: previousReason,
+    priority: previousPriority,
+    timestamp: previousTimestamp,
+    timeout: previousTimeout,
+    onTimeout: previousOnTimeout
+  } = second;
+  return id === previousId && sameScope(scope, previousScope) && reason === previousReason && priority === previousPriority && timestamp === previousTimestamp && timeout === previousTimeout && onTimeout === previousOnTimeout;
+}
+function areBlockingInfosEqual(first, second) {
+  return first === second || first.length === second.length && first.every((blocker, index) => {
+    const previous = second[index];
+    return typeUtils.isDefined(previous) && sameBlocker(blocker, previous);
+  });
+}
+function matchingBlockers(snapshot, matchesScope) {
+  return snapshot.filter(({ scope }) => matchesScope(scope));
+}
+function orderedBlockers(blockers) {
+  return Object.freeze(
+    blockers.sort(({ priority: first }, { priority: second }) => second - first)
+  );
+}
+function projectBlockingInfo(snapshot, scope) {
+  const matchesScope = createScopeObservationMatcher(scope);
+  return orderedBlockers(matchingBlockers(snapshot, matchesScope));
+}
+function createBlockingInfoSelector(scope) {
+  const matchesScope = createScopeObservationMatcher(scope);
+  let previousSnapshot;
+  let previousMatches = [];
+  let result = Object.freeze([]);
+  return ({ blockingSnapshot }) => {
+    if (blockingSnapshot === previousSnapshot) {
+      return result;
+    }
+    const matches = matchingBlockers(blockingSnapshot, matchesScope);
+    const unchanged = areBlockingInfosEqual(matches, previousMatches);
+    previousSnapshot = blockingSnapshot;
+    if (!unchanged) {
+      previousMatches = matches;
+      result = orderedBlockers([...matches]);
+    }
+    return result;
+  };
+}
+
+// src/store/uiBlockingStore.constants.ts
 var DEFAULT_REASON = "Unknown";
 var DEFAULT_PRIORITY = 0;
 var ASYNC_ACTION_PRIORITY = 20;
 var DEVTOOLS_NAME = "UIBlocking";
-function normalizeScopeToArray(scope) {
-  if (typeof scope === "string") {
-    return [scope];
+function validateTimeout(timeout) {
+  if (typeUtils.isUndefined(timeout)) {
+    return;
+  }
+  if (!Number.isFinite(timeout) || timeout > 0 && Date.now() + timeout > Number.MAX_SAFE_INTEGER) {
+    throw new RangeError("Blocker timeout must be finite with a safely representable deadline");
   }
-  return Array.from(scope);
 }
 
-// src/store/uiBlockingStore.actions.ts
-function normalizePriority(priority, fallback = DEFAULT_PRIORITY) {
-  return priority !== void 0 ? Math.max(0, priority) : fallback;
+// src/store/blockingLifecycle/blockingLifecycle.ts
+function copyScope(scope) {
+  return typeUtils.isString(scope) ? scope : Object.freeze([...scope]);
 }
-function createMiddlewareContext(action, blockerId, config, prevState) {
-  return {
-    action,
-    blockerId,
-    config,
-    timestamp: Date.now(),
-    ...prevState && { prevState }
-  };
+function publicConfig(blocker) {
+  const { scope, reason, priority, timestamp, timeout, onTimeout } = blocker;
+  return { scope, reason, priority, timestamp, timeout, onTimeout };
 }
-function toPublicBlockerConfig(blocker) {
+function freezeBlocker(blocker) {
+  return Object.freeze({ ...blocker, scope: copyScope(blocker.scope) });
+}
+function normalizeBlocker(id, config) {
   return {
-    scope: blocker.scope,
-    reason: blocker.reason,
-    priority: blocker.priority,
-    timestamp: blocker.timestamp,
-    timeout: blocker.timeout,
-    onTimeout: blocker.onTimeout
+    id,
+    scope: copyScope(config.scope ?? DEFAULT_SCOPE),
+    reason: config.reason ?? DEFAULT_REASON,
+    priority: Math.max(0, config.priority ?? DEFAULT_PRIORITY),
+    timestamp: config.timestamp ?? Date.now(),
+    timeout: config.timeout,
+    onTimeout: config.onTimeout
   };
 }
-var createUIBlockingActions = (set, get) => ({
-  // State
-  activeBlockers: /* @__PURE__ */ new Map(),
-  middlewares: /* @__PURE__ */ new Map(),
-  registerMiddleware: (name, middleware) => {
-    set((state) => {
-      const newMiddlewares = new Map(state.middlewares);
-      newMiddlewares.set(name, middleware);
-      return { middlewares: newMiddlewares };
-    });
-  },
-  unregisterMiddleware: (name) => {
-    set((state) => {
-      const newMiddlewares = new Map(state.middlewares);
-      newMiddlewares.delete(name);
-      return { middlewares: newMiddlewares };
-    });
-  },
-  runMiddlewares: async (context) => {
-    const { middlewares } = get();
-    for (const [, middleware] of middlewares) {
+function createBlockingLifecycle() {
+  const blockers = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const observers = /* @__PURE__ */ new Map();
+  const pendingPublications = [];
+  let snapshot = Object.freeze([]);
+  let isDelivering = false;
+  function getSnapshot() {
+    return snapshot;
+  }
+  function deliverEvent(event2) {
+    const eventObservers = [...observers];
+    for (const [registration, observer] of eventObservers) {
+      if (!observers.has(registration)) {
+        continue;
+      }
       try {
-        await middleware(context);
+        void Promise.resolve(observer(event2)).catch(() => void 0);
       } catch {
       }
     }
-  },
-  // Actions
-  /**
-   * Adds a new blocker or overwrites an existing one.
-   *
-   * If a blocker with the same ID already exists, it will be replaced and any
-   * existing timeout will be cleared. The blocker is active immediately after
-   * being added. Triggers middleware with 'add' action.
-   *
-   * @param id - Unique identifier for the blocker. Must be unique within the store.
-   * @param config - Blocker configuration. All fields are optional with defaults applied.
-   *
-   * @example
-   * Basic usage
-   * ```ts
-   * store.getState().addBlocker('save-operation', {
-   *   scope: 'form',
-   *   reason: 'Saving data...',
-   *   priority: 70
-   * });
-   * ```
-   *
-   * @example
-   * With timeout
-   * ```ts
-   * store.getState().addBlocker('api-call', {
-   *   scope: 'global',
-   *   reason: 'Loading...',
-   *   timeout: 30000, // Auto-remove after 30 seconds
-   *   onTimeout: (id) => console.warn(`${id} timed out`)
-   * });
-   * ```
-   *
-   * @see {@link removeBlocker} to remove a blocker
-   * @see {@link updateBlocker} to update an existing blocker
-   */
-  addBlocker: (id, config = {}) => {
-    const existingBlocker = get().activeBlockers.get(id);
-    if (existingBlocker?.timeoutId) {
-      clearTimeout(existingBlocker.timeoutId);
+  }
+  function drainPublications() {
+    if (isDelivering) {
+      return;
     }
-    let timeoutId;
-    if (config.timeout && config.timeout > 0) {
-      timeoutId = setTimeout(() => {
-        const blocker = get().activeBlockers.get(id);
-        if (blocker) {
-          blocker.onTimeout?.(id);
-          void get().runMiddlewares(
-            createMiddlewareContext("timeout", id, {
-              scope: blocker.scope,
-              reason: blocker.reason,
-              priority: blocker.priority,
-              timeout: blocker.timeout
-            })
-          );
-          get().removeBlocker(id);
+    isDelivering = true;
+    try {
+      for (const publication of pendingPublications) {
+        if (publication.kind === "snapshot") {
+          for (const subscriber of subscribers.values()) {
+            try {
+              subscriber(publication.snapshot);
+            } catch {
+            }
+          }
+          if (publication.event) {
+            deliverEvent(publication.event);
+          }
+        } else {
+          deliverEvent(publication.event);
         }
-      }, config.timeout);
+      }
+    } finally {
+      pendingPublications.length = 0;
+      isDelivering = false;
     }
-    set((state) => {
-      const newBlockers = new Map(state.activeBlockers);
-      const storedBlocker = {
-        scope: config.scope ?? DEFAULT_SCOPE,
-        reason: config.reason ?? DEFAULT_REASON,
-        priority: normalizePriority(config.priority),
-        timestamp: config.timestamp ?? Date.now(),
-        timeout: config.timeout,
-        timeoutId,
-        onTimeout: config.onTimeout
-      };
-      newBlockers.set(id, storedBlocker);
-      return { activeBlockers: newBlockers };
+  }
+  function publish(transitionEvent) {
+    snapshot = Object.freeze(Array.from(blockers.values(), ({ config }) => freezeBlocker(config)));
+    pendingPublications.push({ kind: "snapshot", snapshot, event: transitionEvent });
+    drainPublications();
+  }
+  function emit(event2) {
+    pendingPublications.push({ kind: "event", event: event2 });
+    drainPublications();
+  }
+  function event(action, blockerId) {
+    return { action, blockerId, timestamp: Date.now() };
+  }
+  function cancelTimeout(blocker) {
+    if (typeUtils.isDefined(blocker.timeoutId)) {
+      clearTimeout(blocker.timeoutId);
+    }
+  }
+  function handleTimeout(id, blocker) {
+    if (blockers.get(id) !== blocker) {
+      return;
+    }
+    const { onTimeout } = blocker.config;
+    try {
+      onTimeout?.(id);
+    } catch {
+    }
+    const { registration } = blocker;
+    const { scope, reason, priority, timeout: duration } = blocker.config;
+    emit({
+      ...event("timeout", id),
+      registration,
+      config: { scope, reason, priority, timeout: duration }
     });
-    void get().runMiddlewares(
-      createMiddlewareContext("add", id, {
+    if (blockers.get(id) === blocker) {
+      remove(id);
+    }
+  }
+  function scheduleTimeout(id, blocker) {
+    const { timeout } = blocker.config;
+    if (typeUtils.isUndefined(timeout) || timeout <= 0) {
+      return;
+    }
+    let remaining = timeout;
+    function scheduleChunk() {
+      const delay = Math.min(remaining, 2147483647);
+      const startedAt = performance.now();
+      blocker.timeoutId = setTimeout(() => {
+        if (blockers.get(id) !== blocker) {
+          return;
+        }
+        remaining -= Math.max(delay, performance.now() - startedAt);
+        if (remaining <= 0) {
+          handleTimeout(id, blocker);
+          return;
+        }
+        scheduleChunk();
+      }, delay);
+    }
+    scheduleChunk();
+  }
+  function add(id, config = {}) {
+    validateTimeout(config.timeout);
+    const previous = blockers.get(id);
+    if (previous) {
+      cancelTimeout(previous);
+    }
+    const blocker = {
+      config: normalizeBlocker(id, config),
+      registration: Object.freeze({})
+    };
+    blockers.set(id, blocker);
+    scheduleTimeout(id, blocker);
+    publish({
+      ...event("add", id),
+      registration: blocker.registration,
+      config: {
         scope: config.scope,
         reason: config.reason,
         priority: config.priority,
         timeout: config.timeout
-      })
-    );
-  },
-  /**
-   * Updates an existing blocker or creates it if it doesn't exist.
-   *
-   * Merges the provided configuration with existing blocker data. If the timeout
-   * is changed, the timeout timer is restarted. Triggers middleware with 'update' action.
-   *
-   * @param id - Identifier of the blocker to update
-   * @param config - Partial configuration to merge with existing blocker data
-   *
-   * @example
-   * Update blocker reason
-   * ```ts
-   * store.getState().updateBlocker('save', {
-   *   reason: 'Saving additional data...'
-   * });
-   * ```
-   *
-   * @example
-   * Extend timeout
-   * ```ts
-   * store.getState().updateBlocker('api-call', {
-   *   timeout: 60000 // Extend to 60 seconds
-   * });
-   * ```
-   *
-   * @see {@link addBlocker} to create a new blocker
-   */
-  updateBlocker: (id, config = {}) => {
-    const existingBlocker = get().activeBlockers.get(id);
-    if (!existingBlocker) {
-      get().addBlocker(id, config);
+      }
+    });
+  }
+  function applyUpdate(id, config, replace2) {
+    const previous = blockers.get(id);
+    if (!previous) {
+      add(id, config);
       return;
     }
-    let timeoutId = existingBlocker.timeoutId;
-    const timeoutChanged = config.timeout !== void 0 && config.timeout !== existingBlocker.timeout;
+    const oldConfig = previous.config;
+    let nextConfig;
+    if (replace2) {
+      nextConfig = normalizeBlocker(id, {
+        ...config,
+        timestamp: config.timestamp ?? oldConfig.timestamp
+      });
+    } else {
+      nextConfig = {
+        ...oldConfig,
+        scope: copyScope(config.scope ?? oldConfig.scope),
+        reason: config.reason ?? oldConfig.reason,
+        priority: Math.max(0, config.priority ?? oldConfig.priority),
+        timestamp: config.timestamp ?? oldConfig.timestamp,
+        timeout: config.timeout ?? oldConfig.timeout,
+        onTimeout: config.onTimeout ?? oldConfig.onTimeout
+      };
+    }
+    const timeoutChanged = nextConfig.timeout !== oldConfig.timeout;
     if (timeoutChanged) {
-      if (existingBlocker.timeoutId) {
-        clearTimeout(existingBlocker.timeoutId);
-      }
-      if (config.timeout && config.timeout > 0) {
-        const newTimeout = config.timeout;
-        timeoutId = setTimeout(() => {
-          const blocker = get().activeBlockers.get(id);
-          if (blocker) {
-            blocker.onTimeout?.(id);
-            void get().runMiddlewares(
-              createMiddlewareContext("timeout", id, {
-                scope: blocker.scope,
-                reason: blocker.reason,
-                priority: blocker.priority,
-                timeout: blocker.timeout
-              })
-            );
-            get().removeBlocker(id);
-          }
-        }, newTimeout);
-      } else {
-        timeoutId = void 0;
-      }
+      validateTimeout(nextConfig.timeout);
     }
-    const updatedBlocker = {
-      ...existingBlocker,
-      scope: config.scope ?? existingBlocker.scope,
-      reason: config.reason ?? existingBlocker.reason,
-      priority: normalizePriority(config.priority, existingBlocker.priority),
-      timestamp: config.timestamp ?? existingBlocker.timestamp,
-      timeout: config.timeout ?? existingBlocker.timeout,
-      timeoutId,
-      onTimeout: config.onTimeout ?? existingBlocker.onTimeout
-    };
-    set((state) => {
-      const newBlockers = new Map(state.activeBlockers);
-      newBlockers.set(id, updatedBlocker);
-      return { activeBlockers: newBlockers };
-    });
-    void get().runMiddlewares(
-      createMiddlewareContext(
-        "update",
-        id,
-        {
-          scope: updatedBlocker.scope,
-          reason: updatedBlocker.reason,
-          priority: updatedBlocker.priority,
-          timeout: updatedBlocker.timeout,
-          onTimeout: updatedBlocker.onTimeout,
-          timestamp: updatedBlocker.timestamp
-        },
-        {
-          scope: existingBlocker.scope,
-          reason: existingBlocker.reason,
-          priority: existingBlocker.priority,
-          timeout: existingBlocker.timeout,
-          onTimeout: existingBlocker.onTimeout,
-          timestamp: existingBlocker.timestamp
-        }
-      )
-    );
-  },
-  /**
-   * Removes a blocker from the store.
-   *
-   * Clears any associated timeout and triggers middleware with 'remove' action.
-   * Safe to call even if the blocker doesn't exist (no-op in that case).
-   *
-   * @param id - Identifier of the blocker to remove
-   *
-   * @example
-   * ```ts
-   * // Add and remove a blocker
-   * store.getState().addBlocker('temp', { scope: 'form' });
-   * // ... later
-   * store.getState().removeBlocker('temp');
-   * ```
-   *
-   * @see {@link addBlocker} to add a blocker
-   * @see {@link clearAllBlockers} to remove all blockers at once
-   */
-  removeBlocker: (id) => {
-    const prevBlocker = get().activeBlockers.get(id);
-    if (prevBlocker?.timeoutId) {
-      clearTimeout(prevBlocker.timeoutId);
+    let blocker = previous;
+    if (timeoutChanged) {
+      cancelTimeout(previous);
+      blocker = { config: nextConfig, registration: previous.registration };
+    } else {
+      blocker.config = nextConfig;
     }
-    set((state) => {
-      const newBlockers = new Map(state.activeBlockers);
-      newBlockers.delete(id);
-      return { activeBlockers: newBlockers };
-    });
-    if (prevBlocker) {
-      const publicConfig = toPublicBlockerConfig(prevBlocker);
-      void get().runMiddlewares(createMiddlewareContext("remove", id, publicConfig, publicConfig));
+    blockers.set(id, blocker);
+    if (timeoutChanged) {
+      scheduleTimeout(id, blocker);
     }
-  },
-  /**
-   * Checks if one or more scopes are currently blocked.
-   *
-   * Returns true if ANY blocker affects the specified scope(s). Global scope
-   * blockers will cause this to return true for any scope check.
-   *
-   * @param scope - Scope(s) to check. Defaults to "global" if not specified.
-   *                Can be a single scope string or array of scopes.
-   * @returns true if any of the specified scopes are currently blocked
-   *
-   * @example
-   * Single scope check
-   * ```ts
-   * const isFormBlocked = store.getState().isBlocked('form');
-   * console.log(isFormBlocked); // true or false
-   * ```
-   *
-   * @example
-   * Multiple scopes check
-   * ```ts
-   * const isBlocked = store.getState().isBlocked(['form', 'navigation']);
-   * // Returns true if either 'form' OR 'navigation' has active blockers
-   * ```
-   *
-   * @see {@link getBlockingInfo} for detailed blocker information
-   */
-  isBlocked: (scope = DEFAULT_SCOPE) => {
-    const { activeBlockers } = get();
-    const scopes = normalizeScopeToArray(scope);
-    for (const [, blocker] of activeBlockers) {
-      if (blocker.scope === DEFAULT_SCOPE) {
-        return true;
-      }
-      const blockerScopes = normalizeScopeToArray(blocker.scope);
-      if (scopes.some((s) => blockerScopes.includes(s))) {
-        return true;
-      }
+    publish({
+      ...event("update", id),
+      registration: blocker.registration,
+      config: publicConfig(nextConfig),
+      prevState: publicConfig(oldConfig)
+    });
+  }
+  function update(id, config = {}) {
+    applyUpdate(id, config, false);
+  }
+  function replace(id, config) {
+    applyUpdate(id, config, true);
+  }
+  function remove(id) {
+    const previous = blockers.get(id);
+    if (previous) {
+      cancelTimeout(previous);
     }
-    return false;
-  },
-  /**
-   * Gets detailed information about all blockers affecting a specific scope.
-   *
-   * Returns an array of blocker objects sorted by priority (highest first).
-   * Includes global blockers and scope-specific blockers. Each blocker object
-   * contains id, reason, priority, scope, timestamp, and timeout information.
-   *
-   * @param scope - Scope to get blocking information for
-   * @returns Array of {@link BlockerInfo} objects, sorted by priority descending
-   *
-   * @example
-   * Display blocker details
-   * ```ts
-   * const blockers = store.getState().getBlockingInfo('form');
-   * blockers.forEach(blocker => {
-   *   console.log(`${blocker.id}: ${blocker.reason}`);
-   *   console.log(`Priority: ${blocker.priority}`);
-   * });
-   * ```
-   *
-   * @example
-   * Get highest priority blocker
-   * ```ts
-   * const blockers = store.getState().getBlockingInfo('navigation');
-   * const topBlocker = blockers[0]; // Highest priority
-   * if (topBlocker) {
-   *   console.log(`Top blocker: ${topBlocker.reason}`);
-   * }
-   * ```
-   *
-   * @see {@link isBlocked} for a simple boolean check
-   * @see {@link BlockerInfo} for the structure of returned objects
-   */
-  getBlockingInfo: (scope) => {
-    const { activeBlockers } = get();
-    const blockers = [];
-    for (const [id, blocker] of activeBlockers) {
-      const blockerScopes = normalizeScopeToArray(blocker.scope);
-      if (blocker.scope === DEFAULT_SCOPE || blockerScopes.includes(scope)) {
-        const { timeoutId: _timeoutId, ...publicBlocker } = blocker;
-        blockers.push({ id, ...publicBlocker });
-      }
+    blockers.delete(id);
+    if (previous) {
+      const config = publicConfig(previous.config);
+      publish({
+        ...event("remove", id),
+        registration: previous.registration,
+        config,
+        prevState: config
+      });
+    } else {
+      publish();
     }
-    return blockers.sort((a, b) => b.priority - a.priority);
-  },
-  /**
-   * Removes all active blockers from the store.
-   *
-   * Clears all timeouts and triggers middleware with 'clear' action.
-   * Useful for resetting the blocking state.
-   *
-   * @example
-   * ```ts
-   * // Clear all blockers on logout
-   * store.getState().clearAllBlockers();
-   * ```
-   *
-   * @see {@link clearBlockersForScope} to clear blockers for a specific scope
-   */
-  clearAllBlockers: () => {
-    const { activeBlockers } = get();
-    const count = activeBlockers.size;
-    for (const [, blocker] of activeBlockers) {
-      if (blocker.timeoutId) {
-        clearTimeout(blocker.timeoutId);
-      }
+  }
+  function clear() {
+    const count = blockers.size;
+    for (const blocker of blockers.values()) {
+      cancelTimeout(blocker);
     }
-    set({ activeBlockers: /* @__PURE__ */ new Map() });
+    blockers.clear();
     if (count > 0) {
-      void get().runMiddlewares({
-        action: "clear",
-        blockerId: "*",
-        timestamp: Date.now(),
-        count
-      });
+      publish({ ...event("clear", "*"), count });
+    } else {
+      publish();
     }
-  },
-  /**
-   * Removes all blockers that affect a specific scope.
-   *
-   * Clears timeouts for removed blockers and triggers middleware with
-   * 'clear_scope' action. Global scope blockers are NOT cleared by this method.
-   *
-   * @param scope - Scope to clear blockers for
-   *
-   * @example
-   * Clear form blockers
-   * ```ts
-   * // Clear all blockers affecting 'form' scope
-   * store.getState().clearBlockersForScope('form');
-   * ```
-   *
-   * @example
-   * Clear on navigation
-   * ```ts
-   * // Clear navigation blockers when user navigates away
-   * store.getState().clearBlockersForScope('navigation');
-   * ```
-   *
-   * @see {@link clearAllBlockers} to clear all blockers
-   */
-  clearBlockersForScope: (scope) => {
-    const { activeBlockers } = get();
+  }
+  function clearScope(scope) {
     let count = 0;
-    for (const [, blocker] of activeBlockers) {
-      const blockerScopes = normalizeScopeToArray(blocker.scope);
-      if (blockerScopes.includes(scope)) {
-        if (blocker.timeoutId) {
-          clearTimeout(blocker.timeoutId);
-        }
+    for (const [id, blocker] of blockers) {
+      if (scopeMatchesTarget(blocker.config.scope, scope)) {
+        cancelTimeout(blocker);
+        blockers.delete(id);
         count++;
       }
     }
-    set((state) => {
-      const newBlockers = /* @__PURE__ */ new Map();
-      for (const [id, blocker] of state.activeBlockers) {
-        const blockerScopes = normalizeScopeToArray(blocker.scope);
-        if (!blockerScopes.includes(scope)) {
-          newBlockers.set(id, blocker);
-        }
-      }
-      return { activeBlockers: newBlockers };
-    });
     if (count > 0) {
-      void get().runMiddlewares({
-        action: "clear_scope",
-        blockerId: "*",
-        timestamp: Date.now(),
-        scope,
-        count
-      });
+      publish({ ...event("clear_scope", "*"), scope, count });
+    } else {
+      publish();
+    }
+  }
+  function isBlocked(scope = DEFAULT_SCOPE) {
+    for (const { config } of blockers.values()) {
+      if (scopeAffectsObservation(config.scope, scope)) {
+        return true;
+      }
     }
+    return false;
+  }
+  function getBlockingInfo(scope) {
+    return projectBlockingInfo(getSnapshot(), scope);
+  }
+  function subscribe(listener) {
+    const registration = /* @__PURE__ */ Symbol();
+    subscribers.set(registration, listener);
+    return () => {
+      subscribers.delete(registration);
+    };
   }
-});
+  function observe(observer) {
+    const registration = /* @__PURE__ */ Symbol();
+    observers.set(registration, observer);
+    return () => {
+      observers.delete(registration);
+    };
+  }
+  return {
+    add,
+    update,
+    replace,
+    remove,
+    clear,
+    clearScope,
+    isBlocked,
+    getBlockingInfo,
+    getSnapshot,
+    subscribe,
+    observe
+  };
+}
+
+// src/store/uiBlockingStore.actions.ts
+function createActions(lifecycle) {
+  return () => ({
+    blockingSnapshot: lifecycle.getSnapshot(),
+    observeBlockingEvents: lifecycle.observe,
+    addBlocker: lifecycle.add,
+    updateBlocker: lifecycle.update,
+    replaceBlocker: lifecycle.replace,
+    removeBlocker: lifecycle.remove,
+    clearAllBlockers: lifecycle.clear,
+    clearBlockersForScope: lifecycle.clearScope,
+    isBlocked: lifecycle.isBlocked,
+    getBlockingInfo: lifecycle.getBlockingInfo
+  });
+}
+function createLifecycleStateCreator(enhance) {
+  return (set, get, api) => {
+    const lifecycle = createBlockingLifecycle();
+    function setWithLifecycle(...args) {
+      const current = get();
+      if (args[1] === true) {
+        const [update2] = args;
+        const next2 = typeUtils.isFunction(update2) ? update2(current) : update2;
+        if (!Object.is(next2, current)) {
+          set({ ...next2, blockingSnapshot: lifecycle.getSnapshot() }, true);
+        }
+        return;
+      }
+      const [update] = args;
+      const next = typeUtils.isFunction(update) ? update(current) : update;
+      if (!Object.is(next, current)) {
+        set({ ...next, blockingSnapshot: lifecycle.getSnapshot() });
+      }
+    }
+    api.setState = setWithLifecycle;
+    lifecycle.subscribe((blockingSnapshot) => {
+      api.setState({ blockingSnapshot });
+    });
+    return enhance(lifecycle)(setWithLifecycle, get, api);
+  };
+}
+var createUIBlockingActions = createLifecycleStateCreator(createActions);
+function createUIBlockingActionsWithDevtools(options) {
+  return createLifecycleStateCreator((lifecycle) => middleware.devtools(createActions(lifecycle), options));
+}
 var {
   Provider: BaseUIBlockingProvider,
   useContextStoreApi: useUIBlockingContext,
   useContextStore: baseUseUIBlockingStoreFromContext,
   useIsInsideProvider: useIsInsideUIBlockingProvider,
-  useContextStoreOptional: useOptionalUIBlockingContext
-} = reactZustandToolkit.createStoreProvider(createUIBlockingActions, "UIBlocking");
+  useProviderStoreOptional: useOptionalUIBlockingContext
+} = reactZustandToolkit.createStoreProvider(() => createUIBlockingActions, "UIBlocking");
 function useUIBlockingStoreFromContext(selector, equalityFn) {
   if (selector) {
     return baseUseUIBlockingStoreFromContext(selector, equalityFn);
@@ -478,11 +511,12 @@ function UIBlockingProvider({
   middlewares = []
 }) {
   const handleStoreInit = (store) => {
-    middlewares.forEach((mw, index) => {
-      store.getState().registerMiddleware(`provider-middleware-${index.toString()}`, mw);
+    const { observeBlockingEvents } = store.getState();
+    middlewares.forEach((middleware) => {
+      observeBlockingEvents(middleware);
     });
   };
-  return /* @__PURE__ */ jsxRuntime.jsx(BaseUIBlockingProvider, { onStoreInit: handleStoreInit, children });
+  return /* @__PURE__ */ jsxRuntime.jsx(BaseUIBlockingProvider, { input: void 0, onStoreInit: handleStoreInit, children });
 }
 
 // src/store/uiBlockingStore.config.ts
@@ -493,9 +527,9 @@ var devtoolsConfig = {
 
 // src/store/uiBlockingStore.store.ts
 var storeBindings = reactZustandToolkit.createShallowStore(
-  middleware.devtools(createUIBlockingActions, devtoolsConfig)
+  createUIBlockingActionsWithDevtools(devtoolsConfig)
 );
-var uiBlockingStoreApi = storeBindings.useStoreApi;
+var uiBlockingStoreApi = storeBindings.store;
 function useUIBlockingStore(selector, equalityFn) {
   if (selector) {
     return storeBindings.useStore(selector, equalityFn);
@@ -504,16 +538,23 @@ function useUIBlockingStore(selector, equalityFn) {
 }
 
 // src/context/useResolvedStore.ts
-function useOptionalContextStore() {
+var { useResolvedStoreApi: useToolkitStoreApi, useResolvedValue: useToolkitValue } = reactZustandToolkit.createResolvedStoreHooks(uiBlockingStoreApi, useOptionalUIBlockingContext);
+function useResolvedStoreApi() {
+  return useToolkitStoreApi();
+}
+function useResolvedValue(selector, equalityFn) {
+  return useToolkitValue(selector, equalityFn);
+}
+
+// src/context/index.ts
+function useOptionalContext() {
   return useOptionalUIBlockingContext();
 }
-function useResolvedStoreApi() {
-  const contextStore = useOptionalContextStore();
-  return contextStore ?? uiBlockingStoreApi;
+function useResolvedStore() {
+  return useResolvedStoreApi();
 }
-function useResolvedValue(selector) {
-  const store = useResolvedStoreApi();
-  return zustand.useStore(store, shallow.useShallow(selector));
+function useResolvedStoreWithSelector(selector) {
+  return useResolvedValue(selector);
 }
 
 // src/store/blockerId.utils.ts
@@ -521,10 +562,11 @@ var storeSequences = /* @__PURE__ */ new WeakMap();
 function allocateBlockerId(store, prefix) {
   let sequence = storeSequences.get(store) ?? 0;
   let blockerId;
+  const { blockingSnapshot } = store.getState();
   do {
     sequence += 1;
     blockerId = `${prefix}-${String(sequence)}`;
-  } while (store.getState().activeBlockers.has(blockerId));
+  } while (blockingSnapshot.some(({ id }) => id === blockerId));
   storeSequences.set(store, sequence);
   return blockerId;
 }
@@ -570,24 +612,41 @@ function useAsyncAction(actionId, scope, options) {
   );
   return executeWithBlocking;
 }
-function createBlockerConfig(config) {
-  return {
-    scope: config.scope,
-    reason: config.reason,
-    priority: config.priority
-  };
+function useConfigRef(config) {
+  const configRef = react.useRef(config);
+  react.useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+  return configRef;
 }
-function normalizeScopeSnapshot(scope) {
-  if (scope === void 0) {
-    return [DEFAULT_SCOPE];
+var activeHookRegistrations = /* @__PURE__ */ new WeakMap();
+function trackHookRegistration(store, blockerId) {
+  if (process.env.NODE_ENV === "production") {
+    return () => void 0;
   }
-  if (typeof scope === "string") {
-    return [scope];
+  const registrations = activeHookRegistrations.get(store) ?? /* @__PURE__ */ new Map();
+  const count = registrations.get(blockerId) ?? 0;
+  activeHookRegistrations.set(store, registrations);
+  registrations.set(blockerId, count + 1);
+  if (count > 0) {
+    console.warn(
+      `[react-action-guard] Multiple active useActionBlocker hooks registered ID "${blockerId}" in the same store. Use a unique ID per hook; shared IDs can overwrite configuration or remove another hook's blocker during cleanup.`
+    );
   }
-  return scope;
+  return () => {
+    const remaining = (registrations.get(blockerId) ?? 1) - 1;
+    if (remaining > 0) {
+      registrations.set(blockerId, remaining);
+    } else {
+      registrations.delete(blockerId);
+    }
+    if (registrations.size === 0) {
+      activeHookRegistrations.delete(store);
+    }
+  };
 }
 function getScopeSnapshotKey(scope) {
-  return JSON.stringify(normalizeScopeSnapshot(scope));
+  return JSON.stringify(normalizeScope(scope));
 }
 function toBlockerConfigSnapshot(config) {
   return [
@@ -603,74 +662,96 @@ function areBlockerConfigsEqual(first, second) {
   return shallow.shallow(toBlockerConfigSnapshot(first), toBlockerConfigSnapshot(second));
 }
 
-// src/hooks/useBlocker/useBlocker.ts
-function useBlocker(blockerId, config, isActive = true) {
-  const { addBlocker, removeBlocker, updateBlocker } = useResolvedValue((state) => ({
-    addBlocker: state.addBlocker,
-    removeBlocker: state.removeBlocker,
-    updateBlocker: state.updateBlocker
-  }));
+// src/hooks/useActionBlocker/useBlockerRegistration.ts
+function useBlockerRegistration({
+  blockerId,
+  config,
+  endEpisodeOnTimeout = false
+}) {
+  const store = useResolvedStoreApi();
   const lastConfigRef = react.useRef(null);
-  const onTimeoutRef = react.useRef(config.onTimeout);
-  onTimeoutRef.current = config.onTimeout;
-  const handleTimeout = react.useCallback((id) => {
-    onTimeoutRef.current?.(id);
-  }, []);
-  const storeConfig = react.useMemo(
-    () => ({
-      ...config,
-      onTimeout: config.onTimeout ? handleTimeout : void 0
-    }),
-    [config, handleTimeout]
+  const releaseRef = react.useRef(null);
+  const expiredRef = react.useRef(false);
+  const configRef = useConfigRef(config);
+  const handleTimeout = react.useCallback(
+    (id) => {
+      expiredRef.current = endEpisodeOnTimeout;
+      configRef.current.onTimeout?.(id);
+    },
+    [configRef, endEpisodeOnTimeout]
   );
-  react.useEffect(() => {
-    if (!isActive || !blockerId) {
+  const storeConfig = react.useMemo(() => {
+    const shouldTrackTimeout = endEpisodeOnTimeout && typeUtils.isDefined(config.timeout);
+    const hasTimeoutCallback = typeUtils.isDefined(config.onTimeout);
+    let onTimeout;
+    if (shouldTrackTimeout || hasTimeoutCallback) {
+      onTimeout = handleTimeout;
+    }
+    return { ...config, onTimeout };
+  }, [config, handleTimeout, endEpisodeOnTimeout]);
+  const storeConfigRef = useConfigRef(storeConfig);
+  const activate = react.useCallback(() => {
+    if (!blockerId || !typeUtils.isNull(releaseRef.current)) {
       return;
     }
-    addBlocker(blockerId, storeConfig);
-    lastConfigRef.current = storeConfig;
-    return () => {
-      lastConfigRef.current = null;
-      removeBlocker(blockerId);
-    };
-  }, [blockerId, isActive, addBlocker, removeBlocker]);
-  react.useEffect(() => {
-    if (!isActive || !blockerId) {
+    const { addBlocker } = store.getState();
+    expiredRef.current = false;
+    releaseRef.current = trackHookRegistration(store, blockerId);
+    lastConfigRef.current = storeConfigRef.current;
+    addBlocker(blockerId, storeConfigRef.current);
+  }, [blockerId, store, storeConfigRef]);
+  const deactivate = react.useCallback(() => {
+    if (typeUtils.isNull(releaseRef.current)) {
       return;
     }
-    if (lastConfigRef.current !== null && areBlockerConfigsEqual(lastConfigRef.current, storeConfig)) {
+    const { removeBlocker } = store.getState();
+    releaseRef.current();
+    releaseRef.current = null;
+    lastConfigRef.current = null;
+    expiredRef.current = false;
+    removeBlocker(blockerId);
+  }, [blockerId, store]);
+  react.useEffect(() => deactivate, [deactivate]);
+  react.useEffect(() => {
+    if (typeUtils.isNull(lastConfigRef.current) || expiredRef.current || areBlockerConfigsEqual(lastConfigRef.current, storeConfig)) {
       return;
     }
-    updateBlocker(blockerId, storeConfig);
+    const { replaceBlocker } = store.getState();
+    replaceBlocker(blockerId, storeConfig);
     lastConfigRef.current = storeConfig;
-  }, [blockerId, storeConfig, isActive, updateBlocker]);
+  }, [blockerId, store, storeConfig]);
+  return { activate, deactivate };
 }
-function useBlockingInfo(scope = DEFAULT_SCOPE) {
-  const store = useResolvedStoreApi();
-  const activeBlockers = zustand.useStore(store, (state) => state.activeBlockers);
-  return react.useMemo(() => {
-    return store.getState().getBlockingInfo(scope);
-  }, [activeBlockers, scope, store]);
-}
-function useConfigRef(config) {
-  const configRef = react.useRef(config);
+
+// src/hooks/useActionBlocker/useActionBlocker.ts
+function useActionBlocker(blockerId, config, isActive = true) {
+  const { activate, deactivate } = useBlockerRegistration({ blockerId, config });
   react.useEffect(() => {
-    configRef.current = config;
-  }, [config]);
-  return configRef;
+    if (!isActive) {
+      return;
+    }
+    activate();
+    return deactivate;
+  }, [isActive, activate, deactivate]);
+}
+var useBlocker = useActionBlocker;
+function useBlockingInfo(scope = DEFAULT_SCOPE) {
+  const checkedScopes = normalizeScope(scope);
+  const selector = react.useMemo(() => {
+    return createBlockingInfoSelector(checkedScopes);
+  }, [checkedScopes]);
+  return useResolvedValue(selector, areBlockingInfosEqual);
 }
-
-// src/hooks/useConditionalBlocker/useConditionalBlocker.ts
 var DEFAULT_CHECK_INTERVAL = 1e3;
 function useConditionalBlocker(blockerId, config) {
-  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
-    addBlocker: state.addBlocker,
-    removeBlocker: state.removeBlocker
-  }));
-  const intervalRef = react.useRef(null);
+  const { activate, deactivate } = useBlockerRegistration({
+    blockerId,
+    config,
+    endEpisodeOnTimeout: true
+  });
   const isBlockedRef = react.useRef(false);
   const configRef = useConfigRef(config);
-  const checkInterval = config.checkInterval !== void 0 && config.checkInterval > 0 ? config.checkInterval : DEFAULT_CHECK_INTERVAL;
+  const checkInterval = !typeUtils.isUndefined(config.checkInterval) && config.checkInterval > 0 ? config.checkInterval : DEFAULT_CHECK_INTERVAL;
   const checkCondition = react.useCallback(() => {
     const currentConfig = configRef.current;
     const shouldBlock = currentConfig.condition(currentConfig.state);
@@ -678,31 +759,32 @@ function useConditionalBlocker(blockerId, config) {
       return;
     }
     if (shouldBlock) {
-      addBlocker(blockerId, createBlockerConfig(currentConfig));
+      activate();
     } else {
-      removeBlocker(blockerId);
+      deactivate();
     }
     isBlockedRef.current = shouldBlock;
-  }, [blockerId, addBlocker, removeBlocker, configRef]);
+  }, [activate, deactivate, configRef]);
+  react.useEffect(
+    () => () => {
+      deactivate();
+      isBlockedRef.current = false;
+    },
+    [deactivate]
+  );
   react.useEffect(() => {
     checkCondition();
-    intervalRef.current = setInterval(checkCondition, checkInterval);
+    const interval = setInterval(checkCondition, checkInterval);
     return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-      if (isBlockedRef.current) {
-        removeBlocker(blockerId);
-        isBlockedRef.current = false;
-      }
+      clearInterval(interval);
     };
-  }, [checkCondition, blockerId, removeBlocker, checkInterval]);
+  }, [checkCondition, checkInterval]);
 }
 function useConfirmableBlocker(blockerId, config) {
   const [isDialogOpen, setIsDialogOpen] = react.useState(false);
   const [isExecuting, setIsExecuting] = react.useState(false);
-  useBlocker(
+  const executionRef = react.useRef(null);
+  useActionBlocker(
     blockerId,
     {
       ...config,
@@ -711,31 +793,48 @@ function useConfirmableBlocker(blockerId, config) {
     isDialogOpen || isExecuting
   );
   const execute = react.useCallback(() => {
+    if (executionRef.current) {
+      return;
+    }
     setIsDialogOpen(true);
   }, []);
   const onConfirm = react.useCallback(async () => {
+    if (executionRef.current) {
+      return executionRef.current;
+    }
     setIsDialogOpen(false);
     setIsExecuting(true);
-    try {
-      await config.onConfirm();
-    } finally {
-      setIsExecuting(false);
+    async function runConfirmation() {
+      try {
+        await config.onConfirm();
+      } finally {
+        executionRef.current = null;
+        setIsExecuting(false);
+      }
     }
+    const execution = Promise.resolve().then(runConfirmation);
+    executionRef.current = execution;
+    return execution;
   }, [config]);
   const onCancel = react.useCallback(() => {
+    if (executionRef.current) {
+      return;
+    }
     setIsDialogOpen(false);
     config.onCancel?.();
   }, [config]);
+  const { confirmTitle, confirmMessage, confirmButtonText, cancelButtonText } = config;
+  const confirmConfig = {
+    title: confirmTitle ?? "Confirm Action",
+    message: confirmMessage,
+    confirmText: confirmButtonText ?? "Confirm",
+    cancelText: cancelButtonText ?? "Cancel"
+  };
   return {
     execute,
     isDialogOpen,
     isExecuting,
-    confirmConfig: {
-      title: config.confirmTitle ?? "Confirm Action",
-      message: config.confirmMessage,
-      confirmText: config.confirmButtonText ?? "Confirm",
-      cancelText: config.cancelButtonText ?? "Cancel"
-    },
+    confirmConfig,
     onConfirm,
     onCancel
   };
@@ -745,54 +844,63 @@ function useConfirmableBlocker(blockerId, config) {
 function useIsBlocked(scope) {
   return useResolvedValue((state) => state.isBlocked(scope));
 }
-
-// src/hooks/useScheduledBlocker/useScheduledBlocker.utils.ts
 var MAX_TIMEOUT_MS = 2147483647;
 function parseDate(date) {
   return new Date(date).getTime();
 }
 function isValidTimestamp(timestamp) {
-  return !Number.isNaN(timestamp);
+  return Number.isFinite(timestamp) && Math.abs(timestamp) <= 864e13;
 }
 function calculateEndTime(schedule, startTime) {
-  if (schedule.duration) {
+  if (!typeUtils.isUndefined(schedule.duration)) {
     return startTime + schedule.duration;
   }
-  if (schedule.end) {
+  if (!typeUtils.isUndefined(schedule.end)) {
     const endTime = parseDate(schedule.end);
     return isValidTimestamp(endTime) ? endTime : void 0;
   }
   return void 0;
 }
-function isSafeTimeout(delay) {
-  return delay > 0 && delay <= MAX_TIMEOUT_MS;
-}
 function isInBlockingPeriod(startTime, endTime, now) {
   if (startTime > now) {
     return false;
   }
-  if (!endTime) {
+  if (typeUtils.isUndefined(endTime)) {
     return true;
   }
   return endTime > now;
 }
-function isScheduleInPast(startTime, endTime, now) {
-  if (!endTime) {
+function isValidSchedule(schedule, startTime) {
+  const { duration, end } = schedule;
+  if (!isValidTimestamp(startTime)) {
     return false;
   }
-  return endTime <= now && startTime <= now;
+  if (!typeUtils.isUndefined(end)) {
+    const suppliedEnd = parseDate(end);
+    if (!isValidTimestamp(suppliedEnd) || suppliedEnd < startTime) {
+      return false;
+    }
+  }
+  if (!typeUtils.isUndefined(duration)) {
+    if (!Number.isFinite(duration) || duration < 0) {
+      return false;
+    }
+    return isValidTimestamp(startTime + duration);
+  }
+  return true;
 }
 
 // src/hooks/useScheduledBlocker/useScheduledBlocker.ts
 function useScheduledBlocker(blockerId, config) {
-  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
-    addBlocker: state.addBlocker,
-    removeBlocker: state.removeBlocker
-  }));
+  const { activate, deactivate } = useBlockerRegistration({
+    blockerId,
+    config,
+    endEpisodeOnTimeout: true
+  });
   const timeoutsRef = react.useRef({});
   const configRef = useConfigRef(config);
   const scheduleStart = parseDate(config.schedule.start);
-  const scheduleEnd = config.schedule.end === void 0 ? void 0 : parseDate(config.schedule.end);
+  const scheduleEnd = typeUtils.isUndefined(config.schedule.end) ? void 0 : parseDate(config.schedule.end);
   const scheduleDuration = config.schedule.duration;
   const cleanup = react.useCallback(() => {
     if (timeoutsRef.current.start) {
@@ -808,59 +916,69 @@ function useScheduledBlocker(blockerId, config) {
     const currentConfig = configRef.current;
     const startTime = parseDate(currentConfig.schedule.start);
     const now = Date.now();
-    if (!isValidTimestamp(startTime)) {
+    if (!isValidSchedule(currentConfig.schedule, startTime)) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[react-action-guard] Invalid blocking schedule:", currentConfig.schedule);
+      }
+      return;
+    }
+    const endTime = calculateEndTime(currentConfig.schedule, startTime);
+    if (!typeUtils.isUndefined(endTime) && endTime <= startTime) {
       return;
     }
     const scheduleEnd2 = () => {
-      const endTime = calculateEndTime(currentConfig.schedule, startTime);
-      if (!endTime) {
+      if (typeUtils.isUndefined(endTime)) {
         return;
       }
       const remainingTime = endTime - Date.now();
       if (remainingTime > 0) {
-        timeoutsRef.current.end = setTimeout(() => {
-          configRef.current.onScheduleEnd?.();
-          removeBlocker(blockerId);
-        }, remainingTime);
+        timeoutsRef.current.end = setTimeout(scheduleEnd2, Math.min(remainingTime, MAX_TIMEOUT_MS));
+        return;
+      }
+      try {
+        configRef.current.onScheduleEnd?.();
+      } finally {
+        deactivate();
       }
     };
     const startBlocking = () => {
+      const now2 = Date.now();
+      const remainingTime = startTime - now2;
+      if (remainingTime > 0) {
+        timeoutsRef.current.start = setTimeout(
+          startBlocking,
+          Math.min(remainingTime, MAX_TIMEOUT_MS)
+        );
+        return;
+      }
+      if (!isInBlockingPeriod(startTime, endTime, now2)) {
+        return;
+      }
       const cfg = configRef.current;
-      addBlocker(blockerId, createBlockerConfig(cfg));
-      cfg.onScheduleStart?.();
+      activate();
       scheduleEnd2();
+      cfg.onScheduleStart?.();
     };
     if (startTime > now) {
       const delay = startTime - now;
-      if (!isSafeTimeout(delay)) {
-        return;
-      }
-      timeoutsRef.current.start = setTimeout(startBlocking, delay);
+      timeoutsRef.current.start = setTimeout(startBlocking, Math.min(delay, MAX_TIMEOUT_MS));
     } else {
-      const endTime = calculateEndTime(currentConfig.schedule, startTime);
       if (isInBlockingPeriod(startTime, endTime, now)) {
-        startBlocking();
-      } else if (isScheduleInPast(startTime, endTime, now)) {
-        return;
+        try {
+          startBlocking();
+        } catch (error) {
+          cleanup();
+          deactivate();
+          throw error;
+        }
       }
     }
     return () => {
       cleanup();
-      removeBlocker(blockerId);
+      deactivate();
     };
-  }, [
-    blockerId,
-    addBlocker,
-    removeBlocker,
-    cleanup,
-    scheduleStart,
-    scheduleEnd,
-    scheduleDuration,
-    configRef
-  ]);
+  }, [activate, deactivate, cleanup, scheduleStart, scheduleEnd, scheduleDuration, configRef]);
 }
-
-// src/middleware/analyticsMiddleware.utils.ts
 function capitalizeFirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -875,13 +993,13 @@ function buildEventData(context) {
     blocker_id: context.blockerId
   };
   const { scope, reason, priority } = context.config ?? {};
-  if (scope !== void 0) {
-    eventData.scope = Array.isArray(scope) ? scope.join(",") : scope;
+  if (!typeUtils.isUndefined(scope)) {
+    eventData.scope = typeUtils.isArray(scope) ? scope.join(",") : scope;
   }
-  if (reason !== void 0) {
+  if (!typeUtils.isUndefined(reason)) {
     eventData.reason = reason;
   }
-  if (priority !== void 0) {
+  if (!typeUtils.isUndefined(priority)) {
     eventData.priority = priority;
   }
   return eventData;
@@ -940,21 +1058,14 @@ function createAnalyticsMiddleware(config) {
 }
 
 // src/middleware/configureMiddleware.ts
-var CONFIGURE_MIDDLEWARE_PREFIX = "middleware-";
+var configuredReleases = [];
 function configureMiddleware(middlewares) {
-  const store = uiBlockingStoreApi.getState();
-  store.middlewares.forEach((_, name) => {
-    if (name.startsWith(CONFIGURE_MIDDLEWARE_PREFIX)) {
-      store.unregisterMiddleware(name);
-    }
-  });
-  middlewares.forEach((middleware, index) => {
-    const name = `${CONFIGURE_MIDDLEWARE_PREFIX}${index.toString()}`;
-    store.registerMiddleware(name, middleware);
-  });
+  const { observeBlockingEvents } = uiBlockingStoreApi.getState();
+  for (const release of configuredReleases) {
+    release();
+  }
+  configuredReleases = middlewares.map(observeBlockingEvents);
 }
-
-// src/middleware/loggerMiddleware.utils.ts
 function getActionEmoji(action) {
   switch (action) {
     case "add":
@@ -982,7 +1093,7 @@ function extractConfigDetails(config) {
     scope,
     reason
   };
-  if (priority !== void 0) {
+  if (!typeUtils.isUndefined(priority)) {
     details.priority = priority;
   }
   return details;
@@ -990,19 +1101,19 @@ function extractConfigDetails(config) {
 function formatLogData(context) {
   const configDetails = extractConfigDetails(context.config);
   const logData = {};
-  if (context.scope !== void 0) {
+  if (!typeUtils.isUndefined(context.scope)) {
     logData.scope = context.scope;
   }
-  if (context.count !== void 0) {
+  if (!typeUtils.isUndefined(context.count)) {
     logData.count = context.count;
   }
-  if (Object.keys(configDetails).length > 0) {
+  if (typeUtils.isNonEmptyArray(Object.keys(configDetails))) {
     logData.config = configDetails;
   }
   if (context.prevState) {
     logData.prevState = extractConfigDetails(context.prevState);
   }
-  if (Object.keys(logData).length === 0) {
+  if (!typeUtils.isNonEmptyArray(Object.keys(logData))) {
     return configDetails;
   }
   return Object.keys(logData).length === 1 && logData.config ? configDetails : logData;
@@ -1017,43 +1128,78 @@ function loggerMiddleware(context) {
 }
 
 // src/middleware/performanceMiddleware.utils.ts
-function handleAddAction(blockerId, timestamp, blockStartTimes) {
-  blockStartTimes.set(blockerId, timestamp);
+function finalizeTrackedBlocks(endedBlocks, timestamp, threshold, onSlowBlock) {
+  for (const [id, tracked] of endedBlocks) {
+    const duration = timestamp - tracked.timestamp;
+    if (duration >= threshold) {
+      try {
+        onSlowBlock?.(id, duration);
+      } catch {
+      }
+    }
+  }
 }
 
 // src/middleware/performanceMiddleware.ts
 var DEFAULT_SLOW_BLOCK_THRESHOLD = 3e3;
-var ACTION_ADD = "add";
-var ACTION_REMOVE = "remove";
-function handleRemoveAction(context, blockStartTimes, slowBlockThreshold, onSlowBlock) {
-  const startTime = blockStartTimes.get(context.blockerId);
-  if (startTime === void 0) {
-    return;
-  }
-  const duration = context.timestamp - startTime;
-  blockStartTimes.delete(context.blockerId);
-  if (duration >= slowBlockThreshold) {
-    onSlowBlock?.(context.blockerId, duration);
-  }
-}
 function createPerformanceMiddleware(config = {}) {
   const { slowBlockThreshold = DEFAULT_SLOW_BLOCK_THRESHOLD, onSlowBlock } = config;
-  const blockStartTimes = /* @__PURE__ */ new Map();
+  const trackedBlocks = /* @__PURE__ */ new Map();
+  const registrations = /* @__PURE__ */ new WeakMap();
   return (context) => {
-    if (context.action === ACTION_ADD) {
-      handleAddAction(context.blockerId, context.timestamp, blockStartTimes);
-    } else if (context.action === ACTION_REMOVE) {
-      handleRemoveAction(context, blockStartTimes, slowBlockThreshold, onSlowBlock);
+    const { action, blockerId, timestamp, config: blockerConfig, scope, registration } = context;
+    if (action === "add") {
+      const tracked = { timestamp, scope: normalizeScope(blockerConfig?.scope), registration };
+      trackedBlocks.set(blockerId, tracked);
+      if (typeUtils.isDefined(registration)) {
+        registrations.set(registration, tracked);
+      }
+    } else if (action === "update") {
+      const tracked = trackedBlocks.get(blockerId);
+      if (typeUtils.isDefined(tracked) && typeUtils.isDefined(blockerConfig?.scope)) {
+        tracked.scope = normalizeScope(blockerConfig.scope);
+      }
+    } else {
+      const endedBlocks = /* @__PURE__ */ new Map();
+      if (action === "remove" || action === "timeout") {
+        let tracked = trackedBlocks.get(blockerId);
+        if (typeUtils.isDefined(registration)) {
+          tracked = registrations.get(registration);
+        }
+        if (typeUtils.isDefined(tracked)) {
+          endedBlocks.set(blockerId, tracked);
+          if (trackedBlocks.get(blockerId) === tracked) {
+            trackedBlocks.delete(blockerId);
+          }
+        }
+      } else {
+        for (const [id, tracked] of trackedBlocks) {
+          const cleared = action === "clear" || typeUtils.isDefined(scope) && scopeMatchesTarget(tracked.scope, scope);
+          if (cleared) {
+            endedBlocks.set(id, tracked);
+            trackedBlocks.delete(id);
+          }
+        }
+      }
+      for (const tracked of endedBlocks.values()) {
+        const { registration: trackedRegistration } = tracked;
+        if (typeUtils.isDefined(trackedRegistration)) {
+          registrations.delete(trackedRegistration);
+        }
+      }
+      finalizeTrackedBlocks(endedBlocks, timestamp, slowBlockThreshold, onSlowBlock);
     }
   };
 }
 
 // src/createTypedHooks.ts
 function createTypedHooks() {
+  const useTypedActionBlocker = (blockerId, config, isActive) => {
+    useActionBlocker(blockerId, config, isActive);
+  };
   return {
-    useBlocker: (blockerId, config, isActive) => {
-      useBlocker(blockerId, config, isActive);
-    },
+    useActionBlocker: useTypedActionBlocker,
+    useBlocker: useTypedActionBlocker,
     useIsBlocked: (scope) => {
       return useIsBlocked(scope);
     },
@@ -1064,24 +1210,20 @@ function createTypedHooks() {
   };
 }
 
-// src/index.ts
-function useOptionalContext() {
-  return useOptionalUIBlockingContext();
-}
-function useResolvedStore() {
-  return useResolvedStoreApi();
-}
-function useResolvedStoreWithSelector(selector) {
-  return useResolvedValue(selector);
-}
-
+exports.DEFAULT_SCOPE = DEFAULT_SCOPE;
 exports.UIBlockingProvider = UIBlockingProvider;
 exports.configureMiddleware = configureMiddleware;
 exports.createAnalyticsMiddleware = createAnalyticsMiddleware;
+exports.createBlockingLifecycle = createBlockingLifecycle;
 exports.createPerformanceMiddleware = createPerformanceMiddleware;
 exports.createTypedHooks = createTypedHooks;
 exports.loggerMiddleware = loggerMiddleware;
+exports.normalizeScope = normalizeScope;
+exports.resolveScope = resolveScope;
+exports.scopeAffectsObservation = scopeAffectsObservation;
+exports.scopeMatchesTarget = scopeMatchesTarget;
 exports.uiBlockingStoreApi = uiBlockingStoreApi;
+exports.useActionBlocker = useActionBlocker;
 exports.useAsyncAction = useAsyncAction;
 exports.useBlocker = useBlocker;
 exports.useBlockingInfo = useBlockingInfo;