sibujs 3.4.0 → 4.0.0

package/dist/chunk-O3QQ3XOL.js

@@ -0,0 +1,61 @@
+import {
+  isSSR
+} from "./chunk-TIRZCERI.js";
+import {
+  signal
+} from "./chunk-W55YHPEP.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-VPP2FONR.js";
+
+// src/core/rendering/context.ts
+var _isDev = isDev();
+function context(defaultValue) {
+  const [getValue, setValue] = signal(defaultValue);
+  const warnIfSSR = (method) => {
+    if (!_isDev || !isSSR()) return;
+    devWarn(
+      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
+    );
+  };
+  const ctx = {
+    provide(value) {
+      warnIfSSR("provide");
+      const previous = getValue();
+      setValue(value);
+      return () => setValue(previous);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      warnIfSSR("set");
+      setValue(value);
+    },
+    withContext(value, fn) {
+      warnIfSSR("withContext");
+      const previous = getValue();
+      setValue(value);
+      try {
+        const result = fn();
+        if (_isDev && result !== null && typeof result?.then === "function") {
+          devWarn(
+            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
+          );
+        }
+        return result;
+      } finally {
+        setValue(previous);
+      }
+    }
+  };
+  return ctx;
+}
+
+export {
+  context
+};

package/dist/{chunk-BUKYCWHX.js → chunk-PBQEW5VW.js}

@@ -1,14 +1,15 @@
 import {
   isSSR
-} from "./chunk-S3NFJO6L.js";
+} from "./chunk-TIRZCERI.js";
 import {
   cleanup,
   retrack,
   untracked
-} from "./chunk-OOUQUCNN.js";
+} from "./chunk-ACBT6UZS.js";
 import {
-  devAssert
-} from "./chunk-COY6PUD2.js";
+  devAssert,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -37,7 +38,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -50,11 +51,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g.__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) {
@@ -131,6 +133,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;

package/dist/{chunk-H5FI5WDP.js → chunk-RRIDJQ5C.js}

@@ -1,14 +1,14 @@
 import {
   isSSR
-} from "./chunk-S3NFJO6L.js";
+} from "./chunk-TIRZCERI.js";
 import {
   resumeTracking,
   suspendTracking,
   track
-} from "./chunk-OOUQUCNN.js";
+} from "./chunk-ACBT6UZS.js";
 import {
   devAssert
-} from "./chunk-COY6PUD2.js";
+} from "./chunk-VPP2FONR.js";
 
 // src/core/signals/watch.ts
 function watch(getter, callback) {

package/dist/{chunk-S3NFJO6L.js → chunk-TIRZCERI.js}

@@ -1,3 +1,8 @@
+import {
+  __require,
+  devWarn
+} from "./chunk-VPP2FONR.js";
+
 // src/core/ssr-context.ts
 var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
 function detectSSRShared() {
@@ -8,20 +13,35 @@ 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);
+var _alsWarned = false;
+function warnMissingAsyncLocalStorage() {
+  if (_alsWarned || als) return;
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (!isNode) return;
+  _alsWarned = true;
+  const version = process.versions.node;
+  devWarn(
+    `SSR request isolation is UNAVAILABLE on this runtime (Node ${version}). AsyncLocalStorage could not be loaded, so concurrent requests share one SSR store: request state and the query cache can bleed between them. Node >= 22.3 is required for isolated SSR under ESM; the CommonJS build works on older versions. A fully synchronous render is unaffected.`
+  );
+}
 function getSSRStore() {
   if (als) {
     const s = als.getStore();
@@ -29,6 +49,10 @@ function getSSRStore() {
   }
   return fallbackStore;
 }
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
 function isSSR() {
   return getSSRStore().ssr;
 }
@@ -50,19 +74,25 @@ function disableSSR() {
   getSSRStore().ssr = false;
 }
 function runInSSRContext(fn) {
-  const store = { ssr: true, suspenseIdCounter: 0 };
+  const store = { ssr: true, suspenseIdCounter: 0, locale: void 0 };
   if (als) {
     return als.run(store, fn);
   }
+  warnMissingAsyncLocalStorage();
   const prevSSR = fallbackStore.ssr;
   const prevCounter = fallbackStore.suspenseIdCounter;
+  const prevLocale = fallbackStore.locale;
   fallbackStore.ssr = true;
   fallbackStore.suspenseIdCounter = 0;
+  fallbackStore.locale = void 0;
+  _shared.fallbackDepth++;
   try {
     return fn();
   } finally {
+    _shared.fallbackDepth--;
     fallbackStore.ssr = prevSSR;
     fallbackStore.suspenseIdCounter = prevCounter;
+    fallbackStore.locale = prevLocale;
   }
 }
 function withSSR(fn) {
@@ -78,6 +108,7 @@ function withSSR(fn) {
 
 export {
   getSSRStore,
+  getRequestStore,
   isSSR,
   getRequestScopedCache,
   enableSSR,