sibujs 3.4.1 → 4.0.1

package/dist/browser.cjs

@@ -81,8 +81,95 @@ function devWarn(message) {
   }
 }
 
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[ERROR_STATE_KEY] = created;
+  return created;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+
 // src/reactivity/track-core.ts
-var _isDev2 = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -90,6 +177,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -174,8 +262,27 @@ function safeInvoke(sub) {
   try {
     sub();
   } catch (err) {
-    if (_isDev2) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s = sub;
+    reportError(err, { phase: s._errorPhase ?? "effect", name: s.__name, node: s._errorNode });
+  }
+}
+function depsChanged(sub) {
+  let node = sub.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
   }
+  return false;
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
@@ -257,7 +364,7 @@ function track(effectFn, subscriber) {
   const sub = subscriber;
   return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s = subscriber;
     if (s._disposed || s._reentrant) return;
@@ -273,13 +380,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -291,9 +402,12 @@ function recordDependency(signal2) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub._hasComputedDep = true;
   const node = allocNode(signal2, sub, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub, node);
@@ -312,9 +426,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -336,19 +451,21 @@ function tickRepeat(sub) {
   return s._runs > maxSubscriberRepeats;
 }
 function cycleError(sub) {
-  if (typeof console !== "undefined") {
-    const name = sub.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i = 0;
@@ -358,11 +475,14 @@ function drainQueue() {
       break;
     }
     const sub = pendingQueue[i++];
+    pendingSet.delete(sub);
+    if (quarantined.size > 0 && quarantined.has(sub)) continue;
+    if (sub._hasComputedDep === true && !depsChanged(sub)) continue;
     if (tickRepeat(sub)) {
       cycleError(sub);
-      break;
+      quarantined.add(sub);
+      continue;
     }
-    pendingSet.delete(sub);
     safeInvoke(sub);
   }
 }
@@ -377,6 +497,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -470,6 +591,7 @@ function notifySubscribers(signal2) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -496,14 +618,14 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _isDev3 = isDev();
-var _runtimeVersion = true ? "3.4.1" : "dev";
+var _isDev2 = isDev();
+var _runtimeVersion = true ? "4.0.1" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
   const existing = g[REGISTRY_KEY];
   if (existing) {
-    if (_isDev3 && !existing.__dupWarned) {
+    if (_isDev2 && !existing.__dupWarned) {
       existing.__dupWarned = true;
       devWarn(
         `Multiple instances of the reactive runtime detected on this page (active: ${existing.version}, duplicate: ${_runtimeVersion}). Reactivity still works \u2014 all copies share the first one \u2014 but de-duplicate sibujs in your bundler (e.g. Vite optimizeDeps.exclude: ['sibujs'] or resolve.dedupe: ['sibujs']).`
@@ -605,70 +727,72 @@ var isBatching = API2.isBatching;
 
 // src/core/signals/signal.ts
 var _g = globalThis;
-var _isDev4 = isDev();
+var _isDev3 = isDev();
 function signal(initial, options) {
-  const state = {
+  const state2 = {
     value: initial,
     __v: 0,
     __sc: 0,
     subsHead: null,
     subsTail: null,
     __activeNode: null,
-    __name: void 0
+    __name: void 0,
+    _d: false,
+    _validate: void 0
   };
-  const debugName = _isDev4 ? options?.name : void 0;
+  const debugName = _isDev3 ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state.__name = debugName;
+  if (debugName) state2.__name = debugName;
   function get() {
-    recordDependency2(state);
-    return state.value;
+    recordDependency2(state2);
+    return state2.value;
   }
-  get.__signal = state;
+  get.__signal = state2;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state.value = newValue;
-      state.__v++;
-      if (_isDev4) {
+      state2.value = newValue;
+      state2.__v++;
+      if (_isDev3) {
         const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
-  } else if (_isDev4) {
+  } else if (_isDev3) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
+      state2.value = newValue;
+      state2.__v++;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   } else {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      state2.value = newValue;
+      state2.__v++;
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   }
-  if (_isDev4) {
+  if (_isDev3) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -702,20 +826,24 @@ function detectSSRShared() {
       const getBuiltin = process.getBuiltinModule;
       if (typeof getBuiltin === "function") {
         mod = getBuiltin("node:async_hooks");
-      } else {
-        const req = Function("return typeof require==='function'?require:null")();
-        if (req) mod = req("node:async_hooks");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
       }
       if (mod) detected = new mod.AsyncLocalStorage();
     }
   } catch {
     detected = null;
   }
-  return { als: detected, fallbackStore: { ssr: false, suspenseIdCounter: 0 } };
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
 }
 var _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
 var als = _shared.als;
 var fallbackStore = _shared.fallbackStore;
+_shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
 function getSSRStore() {
   if (als) {
     const s = als.getStore();
@@ -738,7 +866,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -751,11 +879,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-      console.error(
-        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-      );
-    }
+    reportError(
+      new Error(
+        `effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      ),
+      { phase: "effect" }
+    );
   }
 }
 function disposeEffect(ctx) {
@@ -832,6 +961,8 @@ function effect(effectFn, options) {
   sub.depsTail = null;
   sub._epoch = 0;
   sub._structDirty = false;
+  sub._hasComputedDep = false;
+  sub._errorPhase = "effect";
   sub._runEpoch = 0;
   sub._runs = 0;
   ctx.subscriber = sub;
@@ -1082,13 +1213,13 @@ function idle(timeout = 6e4) {
 
 // src/browser/permissions.ts
 function permissions(name) {
-  const [state, setState] = signal("prompt");
+  const [state2, setState] = signal("prompt");
   let permissionStatus = null;
   let onChange = null;
   let disposed = false;
   if (typeof navigator === "undefined" || !navigator.permissions) {
     setState("unsupported");
-    return { state, dispose: () => {
+    return { state: state2, dispose: () => {
     } };
   }
   navigator.permissions.query({ name }).then((status) => {
@@ -1100,6 +1231,7 @@ function permissions(name) {
     };
     status.addEventListener("change", onChange);
   }).catch(() => {
+    if (disposed) return;
     setState("unsupported");
   });
   function dispose() {
@@ -1110,7 +1242,7 @@ function permissions(name) {
       onChange = null;
     }
   }
-  return { state, dispose };
+  return { state: state2, dispose };
 }
 
 // src/browser/clipboard.ts
@@ -1118,20 +1250,25 @@ function clipboard() {
   const [text, setText] = signal("");
   const [copied, setCopied] = signal(false);
   let copiedTimer = null;
+  let disposed = false;
   async function copy(value) {
+    if (disposed) return;
     if (typeof navigator === "undefined" || !navigator.clipboard) {
       return;
     }
     await navigator.clipboard.writeText(value);
+    if (disposed) return;
     setText(value);
     setCopied(true);
     if (copiedTimer !== null) clearTimeout(copiedTimer);
     copiedTimer = setTimeout(() => {
+      if (disposed) return;
       setCopied(false);
       copiedTimer = null;
     }, 2e3);
   }
   function dispose() {
+    disposed = true;
     if (copiedTimer !== null) {
       clearTimeout(copiedTimer);
       copiedTimer = null;
@@ -1257,26 +1394,137 @@ function dropZone(element, options) {
   return { isOver, dispose };
 }
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g = globalThis;
+  return g[key] ?? (g[key] = create());
+}
+
+// src/utils/singletonResource.ts
+function singletonResource(io) {
+  let original = null;
+  let captured = false;
+  const stack = [];
+  function apply() {
+    if (stack.length > 0) {
+      io.write(stack[stack.length - 1].value);
+      return;
+    }
+    if (captured) {
+      io.write(original);
+      captured = false;
+      original = null;
+    }
+  }
+  return {
+    acquire(value) {
+      if (!captured) {
+        original = io.read();
+        captured = true;
+      }
+      const entry = { value, released: false };
+      stack.push(entry);
+      apply();
+      return {
+        set(next) {
+          if (entry.released) return;
+          entry.value = next;
+          apply();
+        },
+        release() {
+          if (entry.released) return;
+          entry.released = true;
+          const index = stack.indexOf(entry);
+          if (index !== -1) stack.splice(index, 1);
+          apply();
+        }
+      };
+    },
+    ownerCount() {
+      return stack.length;
+    }
+  };
+}
+
+// src/utils/documentResources.ts
+var INERT_LEASE = {
+  set() {
+  },
+  release() {
+  }
+};
+function inertLease() {
+  return INERT_LEASE;
+}
+var titleResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentTitle.v1"),
+  () => singletonResource({
+    read: () => document.title,
+    write: (value) => {
+      document.title = value;
+    }
+  })
+);
+var baseResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentBase.v1"),
+  () => singletonResource({
+    read: () => {
+      const el = document.head.querySelector("base");
+      if (!el) return null;
+      return {
+        href: el.getAttribute("href") ?? void 0,
+        target: el.getAttribute("target") ?? void 0
+      };
+    },
+    write: (spec) => {
+      const existing = document.head.querySelector("base");
+      if (spec === null) {
+        existing?.remove();
+        return;
+      }
+      const el = existing ?? document.head.appendChild(document.createElement("base"));
+      if (spec.href === void 0) el.removeAttribute("href");
+      else el.setAttribute("href", spec.href);
+      if (spec.target === void 0) el.removeAttribute("target");
+      else el.setAttribute("target", spec.target);
+    }
+  })
+);
+var scrollRestorationResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.historyScrollRestoration.v1"),
+  () => singletonResource({
+    read: () => history.scrollRestoration,
+    write: (mode) => {
+      history.scrollRestoration = mode;
+    }
+  })
+);
+function acquireTitle(value) {
+  if (typeof document === "undefined") return inertLease();
+  return titleResource.acquire(value);
+}
+
 // src/browser/title.ts
 function title(value) {
   if (typeof document === "undefined") {
     return () => {
     };
   }
-  const previousTitle = document.title;
   if (typeof value === "function") {
+    let lease2 = null;
     const cleanup3 = effect(() => {
-      document.title = value();
+      const next = value();
+      if (lease2) lease2.set(next);
+      else lease2 = acquireTitle(next);
     });
     return () => {
       cleanup3();
-      document.title = previousTitle;
+      lease2?.release();
+      lease2 = null;
     };
   }
-  document.title = value;
-  return () => {
-    document.title = previousTitle;
-  };
+  const lease = acquireTitle(value);
+  return () => lease.release();
 }
 
 // src/browser/colorScheme.ts
@@ -1590,51 +1838,112 @@ function wakeLock() {
     };
   }
   const api = navigator.wakeLock;
-  let sentinel = null;
+  let current = null;
+  let desire = false;
+  let generation = 0;
+  let inflight = null;
   let disposed = false;
+  function publishActive(value) {
+    if (disposed) return;
+    setActive(value);
+  }
+  function syncReleasedState() {
+    if (current?.released) {
+      current = null;
+      publishActive(false);
+    }
+  }
+  function discard(sentinel) {
+    if (sentinel.released) return;
+    sentinel.release().catch((err) => {
+      reportError(err, { phase: "async", name: "wakeLock(discard)" });
+    });
+  }
   async function request() {
     if (disposed) return;
-    try {
-      const s = await api.request("screen");
-      if (disposed) {
-        s.release().catch(() => {
-        });
-        return;
-      }
-      sentinel = s;
-      setActive(true);
-      sentinel.addEventListener("release", () => {
-        setActive(false);
-      });
-    } catch {
-      setActive(false);
+    desire = true;
+    syncReleasedState();
+    if (current && !current.released) {
+      publishActive(true);
+      return;
     }
+    if (inflight) return inflight;
+    const myGeneration = ++generation;
+    const attempt = (async () => {
+      try {
+        const sentinel = await api.request("screen");
+        if (disposed || !desire || generation !== myGeneration) {
+          discard(sentinel);
+          return;
+        }
+        if (sentinel.released) {
+          publishActive(false);
+          return;
+        }
+        try {
+          sentinel.addEventListener("release", () => {
+            if (current !== sentinel) return;
+            current = null;
+            publishActive(false);
+          });
+        } catch (listenerError) {
+          discard(sentinel);
+          publishActive(false);
+          reportError(listenerError, { phase: "async", name: "wakeLock(listener registration)" });
+          return;
+        }
+        if (sentinel.released) {
+          publishActive(false);
+          return;
+        }
+        current = sentinel;
+        publishActive(true);
+      } catch (err) {
+        if (generation === myGeneration) publishActive(false);
+        reportError(err, { phase: "async", name: "wakeLock(request)" });
+      }
+    })();
+    inflight = attempt;
+    void attempt.finally(() => {
+      if (inflight === attempt) inflight = null;
+    }).catch(() => {
+    });
+    return attempt;
   }
   async function release() {
-    if (sentinel && !sentinel.released) {
-      await sentinel.release();
+    desire = false;
+    generation++;
+    inflight = null;
+    const held = current;
+    current = null;
+    publishActive(false);
+    if (held && !held.released) {
+      await held.release();
     }
-    sentinel = null;
-    setActive(false);
   }
   const onVisibility = () => {
-    if (sentinel?.released && !document.hidden) {
-      request().catch((err) => {
-        if (typeof console !== "undefined") {
-          console.warn("[SibuJS wakeLock] re-acquire failed:", err);
-        }
-      });
-    }
+    syncReleasedState();
+    if (!desire || current || document.hidden) return;
+    request().catch((err) => {
+      reportError(err, { phase: "async", name: "wakeLock(visibility re-acquire)" });
+    });
   };
   document.addEventListener("visibilitychange", onVisibility);
   function dispose() {
-    disposed = true;
+    if (disposed) return;
+    desire = false;
+    generation++;
+    inflight = null;
     document.removeEventListener("visibilitychange", onVisibility);
-    release().catch((err) => {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS wakeLock] release failed:", err);
-      }
-    });
+    const held = current;
+    current = null;
+    setActive(false);
+    disposed = true;
+    if (held && !held.released) {
+      held.release().catch((err) => {
+        reportError(err, { phase: "async", name: "wakeLock(dispose release)" });
+      });
+    }
   }
   return { active, request, release, dispose };
 }