sibujs 4.13.0 → 4.14.0

package/dist/{chunk-QV5WEOFD.js → chunk-SVULV7O4.js}

@@ -1,28 +1,36 @@
+import {
+  registerTransferCollector,
+  takeTransferred,
+  takeTransferredSection
+} from "./chunk-3HZOSMPX.js";
 import {
   derived
-} from "./chunk-YJ57VR6Y.js";
+} from "./chunk-N7A6FKWW.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-BRRRVLHQ.js";
+} from "./chunk-AE32RGWX.js";
 import {
   sanitizeUrl
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
-  getRequestScopedCache
-} from "./chunk-7XHATCIH.js";
+  getRequestScopedCache,
+  isSSR,
+  requestSlot,
+  trackPending
+} from "./chunk-UYTYNCMZ.js";
 import {
   batch,
   signal
-} from "./chunk-GNSRXK34.js";
+} from "./chunk-4FJSAUKB.js";
 import {
   untracked
-} from "./chunk-HVVRXRGO.js";
+} from "./chunk-MIRKTVH4.js";
 import {
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
 
 // src/data/abort.ts
 function isAbortError(error) {
@@ -218,8 +226,34 @@ function sharedView(entry) {
 }
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
-  return getRequestScopedCache("query") ?? globalQueryCache;
+  const requestCache = getRequestScopedCache("query");
+  if (requestCache) return requestCache;
+  primeFromTransfer();
+  return globalQueryCache;
+}
+var SERVER_EFFECT = { server: true };
+function primeFromTransfer() {
+  const entries = takeTransferredSection("q");
+  const now = Date.now();
+  for (const key of Object.keys(entries)) {
+    const record = entries[key];
+    if (!record || typeof record !== "object" || record.d === void 0) continue;
+    if (globalQueryCache.has(key)) continue;
+    const entry = getOrCreateEntry(globalQueryCache, key, record.d);
+    const t = typeof record.t === "number" && Number.isFinite(record.t) ? record.t : now;
+    entry.dataUpdatedAt = Math.min(t, now);
+  }
 }
+registerTransferCollector("q", () => {
+  const cache = getRequestScopedCache("query");
+  if (!cache) return void 0;
+  const out = {};
+  for (const [key, entry] of cache) {
+    if (entry.noTransfer || entry.data === void 0 || entry.error) continue;
+    out[key] = { d: entry.data, t: entry.dataUpdatedAt };
+  }
+  return out;
+});
 function abandonEntry(entry) {
   if (entry.gcTimer) clearTimeout(entry.gcTimer);
   entry.gcTimer = null;
@@ -265,11 +299,13 @@ function query(key, fetcher, options = {}) {
     onError,
     onSettled,
     select,
-    structuralSharing = true
+    structuralSharing = true,
+    ssr = true
   } = options;
+  const onServer = isSSR();
   const resolveKey = typeof key === "function" ? key : () => key;
   const enabledGate = typeof enabled === "function" ? derived(() => Boolean(enabled())) : null;
-  const isEnabled = enabledGate ?? (() => Boolean(enabled));
+  const isEnabled = onServer && !ssr ? () => false : enabledGate ?? (() => Boolean(enabled));
   const cache = getActiveQueryCache();
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
@@ -343,7 +379,7 @@ function query(key, fetcher, options = {}) {
     selectedEntry = entry;
     selectedValue = value;
     setData(value);
-  }) : null;
+  }, SERVER_EFFECT) : null;
   function detachFromEntry() {
     const entry = attachedEntry;
     const key2 = attachedKey;
@@ -426,7 +462,7 @@ function query(key, fetcher, options = {}) {
       runCallback("query onSettled", () => onSettled?.());
       return;
     }
-    entry.promise = promise;
+    entry.promise = trackPending(promise, `query:${key2}`, false);
     try {
       const result = await promise;
       if (entry.generation !== generation) return;
@@ -498,6 +534,7 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const entry = getOrCreateEntry(cache, key2, initialData);
+    if (!ssr) entry.noTransfer = true;
     const reattached = attachedEntry !== entry;
     attachToEntry(entry, key2);
     if (keyChanged) setIsFetching(entry.promise !== null);
@@ -519,15 +556,15 @@ function query(key, fetcher, options = {}) {
     if (on && (entry.data === void 0 || isDataStale)) {
       doFetch();
     }
-  });
-  if (refetchInterval && refetchInterval > 0) {
+  }, SERVER_EFFECT);
+  if (!onServer && refetchInterval && refetchInterval > 0) {
     intervalTimer = setInterval(() => {
       if (!disposed && currentKey) doFetch();
     }, refetchInterval);
   }
   let focusHandler = null;
   let onlineHandler = null;
-  if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+  if (!onServer && typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
     if (refetchOnWindowFocus) {
       focusHandler = () => {
         if (!disposed && currentKey) doFetch();
@@ -956,6 +993,28 @@ function throttle(getter, interval) {
 }
 
 // src/data/resource.ts
+function transferSlot() {
+  return requestSlot("resource:transfer", () => /* @__PURE__ */ new Map());
+}
+function withheldSlot() {
+  return requestSlot("resource:transfer:withheld", () => /* @__PURE__ */ new Set());
+}
+registerTransferCollector("r", () => {
+  const slot = transferSlot();
+  if (!slot || slot.size === 0) return void 0;
+  const withheld = withheldSlot();
+  const out = {};
+  let any = false;
+  for (const [key, value] of slot) {
+    if (withheld?.has(key)) continue;
+    out[key] = value;
+    any = true;
+  }
+  return any ? out : void 0;
+});
+function withholdTransfer(key) {
+  withheldSlot()?.add(key);
+}
 function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
   let source = null;
   let fetcher;
@@ -969,10 +1028,14 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     fetcher = (_source, info) => rawFetcher(info);
     options = fetcherOrOptions ?? {};
   }
-  const [data, setData] = signal(options.initialValue);
+  const transferred = options.key !== void 0 ? takeTransferred("r", options.key) : void 0;
+  const hydrated = transferred !== void 0;
+  const initialValue = hydrated ? transferred : options.initialValue;
+  const onServer = isSSR();
+  const [data, setData] = signal(initialValue);
   const [loading, setLoading] = signal(false);
   const [error, setError] = signal(void 0);
-  let currentData = options.initialValue;
+  let currentData = initialValue;
   function commitData(next, explicit) {
     const sharing = options.structuralSharing ?? true;
     const shared = untracked(
@@ -980,6 +1043,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     );
     currentData = shared.ok ? shared.value : next;
     setData(currentData);
+    if (onServer && options.key !== void 0) transferSlot()?.set(options.key, currentData);
     return currentData;
   }
   let abortController = null;
@@ -1025,19 +1089,28 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       }
     }
   }
+  const run = (sourceValue) => trackPending(doFetch(sourceValue), "resource", false);
   if (source) {
-    effectCleanup = effect(() => {
-      const sourceValue = source();
-      doFetch(sourceValue);
-    });
-  } else if (options.immediate !== false) {
-    doFetch(void 0);
+    let skipFirst = hydrated;
+    effectCleanup = effect(
+      () => {
+        const sourceValue = source();
+        if (skipFirst) {
+          skipFirst = false;
+          return;
+        }
+        run(sourceValue);
+      },
+      { server: true }
+    );
+  } else if (options.immediate !== false && !hydrated) {
+    run(void 0);
   }
   return {
     data,
     loading,
     error,
-    refetch: () => doFetch(source ? source() : void 0),
+    refetch: () => run(source ? source() : void 0),
     mutate: (value) => {
       const newValue = typeof value === "function" ? value(currentData) : value;
       commitData(newValue, true);
@@ -1338,8 +1411,27 @@ function currentScope() {
   }
   return scope;
 }
+function automaticKey(loader, context) {
+  const key = `loader:${context.path}${loader.name ? `:${loader.name}` : ""}`;
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return key;
+  let owners = cache.get("owners");
+  if (!owners) {
+    owners = /* @__PURE__ */ new Map();
+    cache.set("owners", owners);
+  }
+  const owner = owners.get(key);
+  if (owner === void 0) {
+    owners.set(key, loader);
+    return key;
+  }
+  if (owner === loader) return key;
+  withholdTransfer(key);
+  return void 0;
+}
 function executeLoader(loader, context, options) {
-  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const key = options?.key ?? automaticKey(loader, context);
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), { ...options, key });
   const disposeResource = res.dispose;
   res.dispose = () => {
     _disposed.add(res);
@@ -1667,6 +1759,7 @@ export {
   previous,
   debounce,
   throttle,
+  withholdTransfer,
   resource,
   offlineStore,
   syncAdapter,

package/dist/{chunk-C2FAO6VQ.js → chunk-TLS4NVIB.js}

@@ -4,22 +4,22 @@ import {
 } from "./chunk-N5TBYXHW.js";
 import {
   watch
-} from "./chunk-3C56VNCK.js";
+} from "./chunk-RVR5NPFL.js";
 import {
   createId,
   domBinding,
   idSegment
-} from "./chunk-G6366I2A.js";
+} from "./chunk-CCKUNHVU.js";
 import {
   derived
-} from "./chunk-YJ57VR6Y.js";
+} from "./chunk-N7A6FKWW.js";
 import {
   stripHtml
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
   batch,
   signal
-} from "./chunk-GNSRXK34.js";
+} from "./chunk-4FJSAUKB.js";
 
 // src/widgets/Combobox.ts
 var boundComboboxes = /* @__PURE__ */ new WeakMap();

package/dist/{chunk-M25RIH6Y.js → chunk-UUIKJJIK.js}

@@ -1,29 +1,31 @@
 import {
   isBlockedElement
-} from "./chunk-F2UWOZ6J.js";
+} from "./chunk-RVWJGWCL.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-BRRRVLHQ.js";
+} from "./chunk-AE32RGWX.js";
 import {
   sanitizeUrl
-} from "./chunk-EXXSN3BW.js";
+} from "./chunk-B3HOT4TK.js";
 import {
   signal
-} from "./chunk-GNSRXK34.js";
+} from "./chunk-4FJSAUKB.js";
 import {
   bindOwnerScope
-} from "./chunk-HVVRXRGO.js";
+} from "./chunk-MIRKTVH4.js";
 import {
-  DEV,
-  devWarn,
   dispose,
   registerDisposer,
   replaceChildrenSafely,
   reportError
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-S37PZD6I.js";
+import {
+  DEV,
+  devWarn
+} from "./chunk-NT3ZYB5S.js";
 
 // src/performance/scheduler.ts
 var Priority = {

package/dist/chunk-UYTYNCMZ.js

@@ -0,0 +1,199 @@
+import {
+  devWarn,
+  holdHydration,
+  hydrationOwners
+} from "./chunk-NT3ZYB5S.js";
+import {
+  __require
+} from "./chunk-R5U7XKVJ.js";
+
+// src/core/rendering/streamBoundary.ts
+var _a;
+var slot = globalThis[_a = /* @__PURE__ */ Symbol.for("sibujs.streamBoundary.v1")] ?? (globalThis[_a] = { hook: null, current: null });
+function openBoundary(container) {
+  return slot.hook ? slot.hook(container) : null;
+}
+function currentBoundary() {
+  return slot.current;
+}
+function runInBoundary(boundary, fn) {
+  const prev = slot.current;
+  slot.current = boundary;
+  try {
+    return fn();
+  } finally {
+    slot.current = prev;
+  }
+}
+function setBoundaryHook(hook) {
+  slot.hook = hook;
+}
+
+// src/core/ssr-context.ts
+var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
+function detectSSRShared() {
+  let detected = null;
+  try {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      let mod = null;
+      const getBuiltin = process.getBuiltinModule;
+      if (typeof getBuiltin === "function") {
+        mod = getBuiltin("node:async_hooks");
+      } else if (typeof __require === "function") {
+        mod = __require("async_hooks");
+      }
+      if (mod) detected = new mod.AsyncLocalStorage();
+    }
+    const globalAls = globalThis.AsyncLocalStorage;
+    if (!detected && typeof globalAls === "function") detected = new globalAls();
+  } catch {
+    detected = null;
+  }
+  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 assertRequestIsolation(api) {
+  if (als || typeof window !== "undefined") return;
+  throw new Error(
+    `[SibuJS SSR] ${api} needs AsyncLocalStorage to keep concurrent requests apart, and this runtime has none. Use Node >= 22.3 (or the CommonJS build on older Node), Deno or Bun, or enable AsyncLocalStorage on your edge runtime (Cloudflare Workers: the nodejs_compat flag).`
+  );
+}
+function getSSRStore() {
+  if (als) {
+    const s = als.getStore();
+    if (s) return s;
+  }
+  return fallbackStore;
+}
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
+function isSSR() {
+  return getSSRStore().ssr;
+}
+function getRequestScopedCache(name) {
+  if (!isSSR()) return null;
+  const store = getSSRStore();
+  const caches = store.caches ?? (store.caches = /* @__PURE__ */ new Map());
+  let c = caches.get(name);
+  if (!c) {
+    c = /* @__PURE__ */ new Map();
+    caches.set(name, c);
+  }
+  return c;
+}
+function requestSlot(name, create) {
+  const store = getRequestStore();
+  if (!store) return void 0;
+  const slots = store.slots ?? (store.slots = /* @__PURE__ */ new Map());
+  if (!slots.has(name) && create) slots.set(name, create());
+  return slots.get(name);
+}
+var PRERENDER_HOST = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function isServer() {
+  return getSSRStore().ssr || globalThis[PRERENDER_HOST] !== void 0;
+}
+function isClient() {
+  return !isServer();
+}
+function enableSSR() {
+  getSSRStore().ssr = true;
+}
+function disableSSR() {
+  getSSRStore().ssr = false;
+}
+function runInSSRContext(fn) {
+  const store = {
+    ssr: true,
+    suspenseIdCounter: 0,
+    idCounter: 0,
+    locale: void 0,
+    pending: /* @__PURE__ */ new Set(),
+    wake: null
+  };
+  if (als) {
+    return als.run(store, fn);
+  }
+  warnMissingAsyncLocalStorage();
+  const prev = { ...fallbackStore };
+  Object.assign(fallbackStore, store);
+  _shared.fallbackDepth++;
+  try {
+    return fn();
+  } finally {
+    _shared.fallbackDepth--;
+    for (const key of Object.keys(fallbackStore)) {
+      if (!(key in prev)) delete fallbackStore[key];
+    }
+    Object.assign(fallbackStore, prev);
+  }
+}
+function trackPending(promise, label, hydration = true) {
+  const store = getRequestStore();
+  const pending = store?.pending;
+  const sessions = pending || !hydration ? [] : hydrationOwners();
+  if (!pending && sessions.length === 0) return promise;
+  const entry = { label, since: Date.now(), boundary: currentBoundary() ?? void 0 };
+  pending?.add(entry);
+  const release = holdHydration(sessions, entry);
+  const done = () => {
+    pending?.delete(entry);
+    store?.wake?.();
+    release();
+  };
+  try {
+    Promise.resolve(promise).then(done, done);
+  } catch {
+    done();
+  }
+  return promise;
+}
+function withSSR(fn) {
+  const store = getSSRStore();
+  const wasSSR = store.ssr;
+  store.ssr = true;
+  try {
+    return fn();
+  } finally {
+    if (!wasSSR) store.ssr = false;
+  }
+}
+
+export {
+  openBoundary,
+  currentBoundary,
+  runInBoundary,
+  setBoundaryHook,
+  assertRequestIsolation,
+  getSSRStore,
+  getRequestStore,
+  isSSR,
+  getRequestScopedCache,
+  requestSlot,
+  isServer,
+  isClient,
+  enableSSR,
+  disableSSR,
+  runInSSRContext,
+  trackPending,
+  withSSR
+};