sibujs 1.0.0-beta.1

package/dist/ssr.cjs

@@ -0,0 +1,1757 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ssr.ts
+var ssr_exports = {};
+__export(ssr_exports, {
+  Head: () => Head,
+  clearWasmCache: () => clearWasmCache,
+  collectStream: () => collectStream,
+  composeMiddleware: () => composeMiddleware,
+  createAction: () => createAction,
+  createISR: () => createISR,
+  createMicroApp: () => createMicroApp,
+  createMiddlewareChain: () => createMiddlewareChain,
+  createSharedScope: () => createSharedScope,
+  createWasmBridge: () => createWasmBridge,
+  createWorkerPool: () => createWorkerPool,
+  defineRemoteComponent: () => defineRemoteComponent,
+  deserializeState: () => deserializeState,
+  generateStaticSite: () => generateStaticSite,
+  hydrate: () => hydrate,
+  hydrateIslands: () => hydrateIslands,
+  hydrateProgressively: () => hydrateProgressively,
+  isWasmCached: () => isWasmCached,
+  island: () => island,
+  loadRemoteModule: () => loadRemoteModule,
+  loadWasmModule: () => loadWasmModule,
+  preloadWasm: () => preloadWasm,
+  renderToDocument: () => renderToDocument,
+  renderToReadableStream: () => renderToReadableStream,
+  renderToStream: () => renderToStream,
+  renderToString: () => renderToString,
+  renderToSuspenseStream: () => renderToSuspenseStream,
+  resetSSRState: () => resetSSRState,
+  scrollRestoration: () => scrollRestoration,
+  serializeState: () => serializeState,
+  serviceWorker: () => serviceWorker,
+  setCanonical: () => setCanonical,
+  setStructuredData: () => setStructuredData,
+  ssrSuspense: () => ssrSuspense,
+  suspenseSwapScript: () => suspenseSwapScript,
+  wasm: () => wasm,
+  worker: () => worker,
+  workerFn: () => workerFn
+});
+module.exports = __toCommonJS(ssr_exports);
+
+// src/platform/ssr.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderToString(element) {
+  if (element instanceof DocumentFragment) {
+    return Array.from(element.childNodes).map((child) => renderToString(child)).join("");
+  }
+  if (element.nodeType === 3) {
+    return escapeHtml(element.textContent || "");
+  }
+  if (element.nodeType === 8) {
+    const content = (element.textContent || "").replace(/-->/g, "-->");
+    return `<!--${content}-->`;
+  }
+  if (!(element instanceof HTMLElement)) {
+    return element.textContent || "";
+  }
+  const tag = element.tagName.toLowerCase();
+  let html2 = `<${tag}`;
+  for (const attr of Array.from(element.attributes)) {
+    html2 += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  if (element.dataset && !element.dataset.sibuHydrate) {
+    html2 += ` data-sibu-ssr="true"`;
+  }
+  if (VOID_ELEMENTS.has(tag)) {
+    return `${html2} />`;
+  }
+  html2 += ">";
+  for (const child of Array.from(element.childNodes)) {
+    html2 += renderToString(child);
+  }
+  html2 += `</${tag}>`;
+  return html2;
+}
+function hydrate(component, container) {
+  const clientTree = component();
+  hydrateNode(container.firstElementChild, clientTree);
+  container.setAttribute("data-sibu-hydrated", "true");
+}
+function hydrateNode(serverNode, clientNode) {
+  if (!serverNode) return;
+  const serverChildren = Array.from(serverNode.children);
+  const clientChildren = Array.from(clientNode.children);
+  for (let i2 = 0; i2 < Math.min(serverChildren.length, clientChildren.length); i2++) {
+    hydrateNode(serverChildren[i2], clientChildren[i2]);
+  }
+}
+function renderToDocument(component, options = {}) {
+  const content = renderToString(component());
+  const metaTags = (options.meta || []).map(
+    (attrs) => `<meta ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const linkTags = (options.links || []).map(
+    (attrs) => `<link ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const scriptTags = (options.scripts || []).map((src) => `<script src="${escapeAttr(src)}"></script>`).join("\n    ");
+  const bodyAttrs = options.bodyAttrs ? " " + Object.entries(options.bodyAttrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ") : "";
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    ${options.title ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${metaTags}
+    ${linkTags}
+    ${options.headExtra || ""}
+  </head>
+  <body${bodyAttrs}>
+    <div id="app">${content}</div>
+    ${scriptTags}
+  </body>
+</html>`;
+}
+async function* renderToStream(element) {
+  if (element instanceof DocumentFragment) {
+    for (const child of Array.from(element.childNodes)) {
+      yield* renderToStream(child);
+    }
+    return;
+  }
+  if (element.nodeType === 3) {
+    yield escapeHtml(element.textContent || "");
+    return;
+  }
+  if (element.nodeType === 8) {
+    yield `<!--${element.textContent || ""}-->`;
+    return;
+  }
+  if (!(element instanceof HTMLElement)) {
+    yield element.textContent || "";
+    return;
+  }
+  const tag = element.tagName.toLowerCase();
+  let openTag = `<${tag}`;
+  for (const attr of Array.from(element.attributes)) {
+    openTag += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  if (VOID_ELEMENTS.has(tag)) {
+    yield `${openTag} />`;
+    return;
+  }
+  yield `${openTag}>`;
+  for (const child of Array.from(element.childNodes)) {
+    yield* renderToStream(child);
+  }
+  yield `</${tag}>`;
+}
+async function collectStream(stream) {
+  let result = "";
+  for await (const chunk of stream) {
+    result += chunk;
+  }
+  return result;
+}
+function renderToReadableStream(element) {
+  const generator = renderToStream(element);
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await generator.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    cancel() {
+      generator.return(void 0);
+    }
+  });
+}
+function island(id, component) {
+  const el = component();
+  el.setAttribute("data-sibu-island", id);
+  return el;
+}
+function hydrateIslands(container, islands) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  for (const marker2 of Array.from(markers)) {
+    const id = marker2.getAttribute("data-sibu-island") ?? "";
+    const factory = islands[id];
+    if (!factory) continue;
+    const clientTree = factory();
+    hydrateNode(marker2, clientTree);
+    marker2.setAttribute("data-sibu-hydrated", "true");
+  }
+  container.setAttribute("data-sibu-hydrated", "partial");
+}
+function hydrateProgressively(container, islands, options) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  const cleanups = [];
+  for (const marker2 of Array.from(markers)) {
+    const id = marker2.getAttribute("data-sibu-island") ?? "";
+    const factory = islands[id];
+    if (!factory) continue;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            const clientTree = factory();
+            hydrateNode(marker2, clientTree);
+            marker2.setAttribute("data-sibu-hydrated", "true");
+            observer.disconnect();
+            break;
+          }
+        }
+      },
+      { rootMargin: "200px", ...options }
+    );
+    observer.observe(marker2);
+    cleanups.push(() => observer.disconnect());
+  }
+  container.setAttribute("data-sibu-hydrated", "progressive");
+  return () => {
+    for (const cleanup2 of cleanups) cleanup2();
+  };
+}
+var suspenseIdCounter = 0;
+function resetSSRState() {
+  suspenseIdCounter = 0;
+}
+function ssrSuspense(props) {
+  const id = `sibu-sus-${suspenseIdCounter++}`;
+  const fallbackEl = props.fallback();
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-sibu-suspense-id", id);
+  wrapper.appendChild(fallbackEl);
+  const promise = props.content().then((resolvedEl) => ({
+    id,
+    html: renderToString(resolvedEl)
+  }));
+  return { element: wrapper, promise };
+}
+function suspenseSwapScript(id) {
+  const safeId = id.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+  return `<script>(function(){var t=document.getElementById("sibu-resolved-${safeId}");var f=document.querySelector('[data-sibu-suspense-id="${safeId}"]');if(t&&f){while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
+}
+async function* renderToSuspenseStream(element, pendingBoundaries = []) {
+  yield* renderToStream(element);
+  if (pendingBoundaries.length > 0) {
+    const resolved = await Promise.all(pendingBoundaries);
+    for (const { id, html: html2 } of resolved) {
+      yield `<div hidden id="sibu-resolved-${id}">${html2}</div>`;
+      yield suspenseSwapScript(id);
+    }
+  }
+}
+var SSR_DATA_ATTR = "__SIBU_SSR_DATA__";
+function serializeState(state) {
+  const json = JSON.stringify(state).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return `<script>window.${SSR_DATA_ATTR}=${json}</script>`;
+}
+function deserializeState() {
+  if (typeof window === "undefined") return void 0;
+  return window[SSR_DATA_ATTR];
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub2 of subs) {
+    if (sub2._c) {
+      propagateDirty(sub2);
+    } else if (!pendingSet.has(sub2)) {
+      pendingSet.add(sub2);
+      pendingQueue.push(sub2);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i2 = 0;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub2) {
+  sub2();
+  let sig = sub2._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub2._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s2 = sig;
+      s2._d = false;
+      s2._v = s2._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s2 of subs) {
+      if (s2._c) {
+        s2();
+        const nSig = s2._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s2);
+        }
+      } else if (!pendingSet.has(s2)) {
+        pendingSet.add(s2);
+        pendingQueue.push(s2);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i2 = 0;
+      while (i2 < pendingQueue.length) {
+        pendingQueue[i2]();
+        i2++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub2 of subs) {
+      if (sub2._c) {
+        propagateDirty(sub2);
+      } else if (!pendingSet.has(sub2)) {
+        pendingSet.add(sub2);
+        pendingQueue.push(sub2);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub2 of subs) {
+      pendingQueue[directCount++] = sub2;
+    }
+    for (let i3 = 0; i3 < directCount; i3++) {
+      if (pendingQueue[i3]._c) {
+        propagateDirty(pendingQueue[i3]);
+      }
+    }
+    for (let i3 = 0; i3 < directCount; i3++) {
+      if (!pendingQueue[i3]._c) {
+        if (!pendingSet.has(pendingQueue[i3])) {
+          pendingQueue[i3]();
+        }
+      }
+    }
+    let i2 = directCount;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/utils/sanitize.ts
+function sanitize(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
+    return "";
+  }
+  return trimmed;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+function sanitizeAttribute(attr, value) {
+  if (isUrlAttribute(attr)) {
+    return sanitizeUrl(value);
+  }
+  return sanitize(value);
+}
+
+// src/platform/head.ts
+var HEAD_URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "content"]);
+function sanitizeHeadAttr(key, value) {
+  if (HEAD_URL_ATTRS.has(key)) return sanitizeUrl(value);
+  return value;
+}
+var managedElements = [];
+function Head(props) {
+  const anchor = document.createComment("sibu-head");
+  const cleanup2 = () => {
+    for (const el of managedElements) {
+      if (el.parentNode) el.parentNode.removeChild(el);
+    }
+    managedElements.length = 0;
+  };
+  const apply = () => {
+    cleanup2();
+    if (props.title) {
+      if (typeof props.title === "function") {
+        effect(() => {
+          document.title = props.title();
+        });
+      } else {
+        document.title = props.title;
+      }
+    }
+    if (props.meta) {
+      for (const metaProps of props.meta) {
+        const el = document.createElement("meta");
+        for (const [key, value] of Object.entries(metaProps)) {
+          if (typeof value === "function") {
+            effect(() => {
+              el.setAttribute(key, value());
+            });
+          } else {
+            el.setAttribute(key, value);
+          }
+        }
+        document.head.appendChild(el);
+        managedElements.push(el);
+      }
+    }
+    if (props.link) {
+      for (const linkProps of props.link) {
+        const el = document.createElement("link");
+        for (const [key, value] of Object.entries(linkProps)) {
+          el.setAttribute(key, sanitizeHeadAttr(key, value));
+        }
+        document.head.appendChild(el);
+        managedElements.push(el);
+      }
+    }
+    if (props.script) {
+      for (const scriptProps of props.script) {
+        const el = document.createElement("script");
+        for (const [key, value] of Object.entries(scriptProps)) {
+          el.setAttribute(key, sanitizeHeadAttr(key, value));
+        }
+        document.head.appendChild(el);
+        managedElements.push(el);
+      }
+    }
+    if (props.base) {
+      const existing = document.head.querySelector("base");
+      if (existing) existing.remove();
+      const el = document.createElement("base");
+      if (props.base.href) el.href = props.base.href;
+      if (props.base.target) el.target = props.base.target;
+      document.head.appendChild(el);
+      managedElements.push(el);
+    }
+  };
+  apply();
+  return anchor;
+}
+function setStructuredData(data2) {
+  const existing = document.head.querySelector('script[type="application/ld+json"][data-sibu]');
+  if (existing) existing.remove();
+  const script2 = document.createElement("script");
+  script2.type = "application/ld+json";
+  script2.setAttribute("data-sibu", "true");
+  script2.textContent = JSON.stringify(data2);
+  document.head.appendChild(script2);
+  managedElements.push(script2);
+}
+function setCanonical(url) {
+  let link2 = document.head.querySelector('link[rel="canonical"]');
+  if (!link2) {
+    link2 = document.createElement("link");
+    link2.rel = "canonical";
+    document.head.appendChild(link2);
+    managedElements.push(link2);
+  }
+  link2.href = sanitizeUrl(url);
+}
+
+// src/platform/staticSiteGenerator.ts
+async function generateStaticSite(options) {
+  const { routes, renderFn } = options;
+  const pages = [];
+  const errors = [];
+  for (const route of routes) {
+    try {
+      const html2 = await renderFn(route);
+      pages.push({ path: route, html: html2 });
+    } catch (err) {
+      errors.push({
+        path: route,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  return { pages, errors };
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/platform/incrementalRegeneration.ts
+function createISR(options) {
+  const { revalidateAfter, fetcher, initialData } = options;
+  const [data2, setData] = signal(initialData);
+  const [timestamp, setTimestamp] = signal(initialData !== void 0 ? Date.now() : 0);
+  const isStale = () => {
+    const ts = timestamp();
+    if (ts === 0) return true;
+    return Date.now() - ts >= revalidateAfter;
+  };
+  const revalidate = async () => {
+    const result = await fetcher();
+    setData(result);
+    setTimestamp(Date.now());
+  };
+  if (initialData === void 0) {
+    revalidate();
+  }
+  const intervalId = setInterval(() => {
+    revalidate();
+  }, revalidateAfter);
+  const dispose = () => {
+    clearInterval(intervalId);
+  };
+  return { data: data2, isStale, revalidate, dispose };
+}
+
+// src/platform/routeActions.ts
+function createAction(actionFn) {
+  const [data2, setData] = signal(void 0);
+  const [error, setError] = signal(void 0);
+  const [loading, setLoading] = signal(false);
+  const submit = async (input2) => {
+    batch(() => {
+      setLoading(true);
+      setError(void 0);
+    });
+    try {
+      const result = await actionFn(input2);
+      batch(() => {
+        setData(result);
+        setLoading(false);
+      });
+      return result;
+    } catch (err) {
+      const actionError = err instanceof Error ? err : new Error(String(err));
+      batch(() => {
+        setError(actionError);
+        setLoading(false);
+      });
+      throw actionError;
+    }
+  };
+  return { data: data2, error, loading, submit };
+}
+
+// src/platform/scrollRestoration.ts
+function scrollRestoration(options) {
+  const mode = options?.mode ?? "auto";
+  const positions = /* @__PURE__ */ new Map();
+  let popstateHandler = null;
+  let currentKey = null;
+  const save = (key) => {
+    positions.set(key, {
+      x: window.scrollX,
+      y: window.scrollY
+    });
+    currentKey = key;
+  };
+  const restore = (key) => {
+    const pos = positions.get(key);
+    if (pos) {
+      window.scrollTo(pos.x, pos.y);
+    }
+    currentKey = key;
+  };
+  const getPosition = (key) => {
+    return positions.get(key);
+  };
+  if (mode === "auto") {
+    popstateHandler = () => {
+      if (currentKey) {
+        save(currentKey);
+      }
+    };
+    window.addEventListener("popstate", popstateHandler);
+  }
+  const dispose = () => {
+    if (popstateHandler) {
+      window.removeEventListener("popstate", popstateHandler);
+      popstateHandler = null;
+    }
+    positions.clear();
+  };
+  return { save, restore, getPosition, dispose };
+}
+
+// src/platform/routeMiddleware.ts
+function composeMiddleware(...fns) {
+  return async (context, next) => {
+    let index = -1;
+    const dispatch = async (i2) => {
+      if (i2 <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i2;
+      if (i2 < fns.length) {
+        await fns[i2](context, () => dispatch(i2 + 1));
+      } else {
+        await next();
+      }
+    };
+    await dispatch(0);
+  };
+}
+function createMiddlewareChain() {
+  const middlewares = [];
+  const use2 = (fn) => {
+    middlewares.push(fn);
+  };
+  const run = async (context) => {
+    const composed = composeMiddleware(...middlewares);
+    await composed(context, () => {
+    });
+  };
+  return { use: use2, run };
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch {
+      return;
+    }
+    if (typeof value === "boolean") {
+      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
+        el[attr] = value;
+      } else if (value) {
+        el.setAttribute(attr, "");
+      } else {
+        el.removeAttribute(attr);
+      }
+      return;
+    }
+    const str = sanitizeAttribute(attr, String(value));
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, str);
+    }
+  }
+  const teardown = track(commit);
+  return teardown;
+}
+
+// src/reactivity/bindChildNode.ts
+function bindChildNode(placeholder, getter) {
+  let lastNodes = [];
+  function commit() {
+    let result;
+    try {
+      result = getter();
+    } catch {
+      return;
+    }
+    for (const node of lastNodes) {
+      node.parentNode?.removeChild(node);
+    }
+    lastNodes = [];
+    if (result == null) return;
+    const parent = placeholder.parentNode;
+    if (!parent) return;
+    const anchor = placeholder.nextSibling;
+    const newNodes = [];
+    const insertItem = (item) => {
+      const node = item instanceof Node ? item : document.createTextNode(String(item));
+      parent.insertBefore(node, anchor);
+      newNodes.push(node);
+    };
+    if (Array.isArray(result)) {
+      for (const item of result) insertItem(item);
+    } else {
+      insertItem(result);
+    }
+    lastNodes = newNodes;
+  }
+  return track(commit);
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  activeBindingCount++;
+}
+
+// src/core/rendering/tagFactory.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var kebabCache = /* @__PURE__ */ new Map();
+function toKebab(prop) {
+  let cached = kebabCache.get(prop);
+  if (cached !== void 0) return cached;
+  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+  kebabCache.set(prop, cached);
+  return cached;
+}
+function applyStyle(el, style2) {
+  if (!style2) return;
+  if (typeof style2 === "function") {
+    const teardown = track(() => {
+      el.setAttribute("style", style2());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof style2 === "string") {
+    el.setAttribute("style", style2);
+    return;
+  }
+  const htmlEl = el;
+  for (const prop in style2) {
+    const val = style2[prop];
+    const name = toKebab(prop);
+    if (typeof val === "function") {
+      const getter = val;
+      const teardown = track(() => {
+        htmlEl.style.setProperty(name, String(getter()));
+      });
+      registerDisposer(el, teardown);
+    } else {
+      htmlEl.style.setProperty(name, String(val));
+    }
+  }
+}
+function applyClass(el, cls) {
+  if (cls == null) return;
+  if (typeof cls === "string") {
+    el.setAttribute("class", cls);
+    return;
+  }
+  if (typeof cls === "function") {
+    const getter = cls;
+    const teardown = track(() => {
+      el.setAttribute("class", getter());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof cls === "object") {
+    const obj = cls;
+    let hasReactive = false;
+    for (const name in obj) {
+      if (typeof obj[name] === "function") {
+        hasReactive = true;
+        break;
+      }
+    }
+    if (hasReactive) {
+      const update = () => {
+        let result = "";
+        for (const name in obj) {
+          const val = obj[name];
+          const active = typeof val === "function" ? val() : val;
+          if (active) result = result ? `${result} ${name}` : name;
+        }
+        el.setAttribute("class", result);
+      };
+      const teardown = track(update);
+      registerDisposer(el, teardown);
+    } else {
+      let result = "";
+      for (const name in obj) {
+        if (obj[name]) result = result ? `${result} ${name}` : name;
+      }
+      el.setAttribute("class", result);
+    }
+  }
+}
+function renderChild(child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function appendOneChild(el, child) {
+  if (typeof child === "function") {
+    const placeholder = document.createComment("bind:child");
+    el.appendChild(placeholder);
+    const teardown = bindChildNode(placeholder, child);
+    registerDisposer(el, teardown);
+  } else {
+    el.appendChild(renderChild(child));
+  }
+}
+function appendChildren(el, nodes) {
+  if (Array.isArray(nodes)) {
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      const c = nodes[i2];
+      if (Array.isArray(c)) {
+        for (let j = 0; j < c.length; j++) {
+          appendOneChild(el, c[j]);
+        }
+      } else {
+        appendOneChild(el, c);
+      }
+    }
+  } else {
+    appendOneChild(el, nodes);
+  }
+}
+function isTagProps(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Node);
+}
+var tagFactory = (tag, ns) => (first, second) => {
+  let props;
+  if (first === void 0) {
+    props = {};
+  } else if (isTagProps(first)) {
+    props = first;
+  } else if (second !== void 0) {
+    props = { class: first, nodes: second };
+  } else {
+    props = { nodes: first };
+  }
+  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+  for (const key in props) {
+    const value = props[key];
+    if (value == null) continue;
+    switch (key) {
+      case "id":
+        el.id = value;
+        break;
+      case "class":
+        applyClass(el, value);
+        break;
+      case "style":
+        applyStyle(el, value);
+        break;
+      case "ref":
+        if (value && typeof value === "object" && "current" in value) {
+          value.current = el;
+        }
+        break;
+      case "on": {
+        const handlers = value;
+        const eventNames = [];
+        for (const ev in handlers) {
+          el.addEventListener(ev, handlers[ev]);
+          eventNames.push(ev);
+        }
+        if (eventNames.length) {
+          el.__sibu_events__ = eventNames;
+        }
+        break;
+      }
+      case "nodes":
+        appendChildren(el, value);
+        break;
+      default:
+        if (key.toLowerCase().startsWith("on")) break;
+        if (typeof value === "function") {
+          const teardown = bindAttribute(el, key, value);
+          registerDisposer(el, teardown);
+        } else if (typeof value === "boolean") {
+          if (value) el.setAttribute(key, "");
+          else el.removeAttribute(key);
+        } else {
+          el.setAttribute(key, sanitizeAttribute(key, String(value)));
+        }
+    }
+  }
+  return el;
+};
+
+// src/core/rendering/html.ts
+var html = tagFactory("html");
+var head = tagFactory("head");
+var body = tagFactory("body");
+var title = tagFactory("title");
+var div = tagFactory("div");
+var span = tagFactory("span");
+var section = tagFactory("section");
+var article = tagFactory("article");
+var header = tagFactory("header");
+var footer = tagFactory("footer");
+var nav = tagFactory("nav");
+var main = tagFactory("main");
+var aside = tagFactory("aside");
+var address = tagFactory("address");
+var p = tagFactory("p");
+var h1 = tagFactory("h1");
+var h2 = tagFactory("h2");
+var h3 = tagFactory("h3");
+var h4 = tagFactory("h4");
+var h5 = tagFactory("h5");
+var h6 = tagFactory("h6");
+var blockquote = tagFactory("blockquote");
+var dd = tagFactory("dd");
+var dl = tagFactory("dl");
+var dt = tagFactory("dt");
+var figcaption = tagFactory("figcaption");
+var figure = tagFactory("figure");
+var hr = tagFactory("hr");
+var li = tagFactory("li");
+var ol = tagFactory("ol");
+var ul = tagFactory("ul");
+var pre = tagFactory("pre");
+var a = tagFactory("a");
+var abbr = tagFactory("abbr");
+var b = tagFactory("b");
+var bdi = tagFactory("bdi");
+var bdo = tagFactory("bdo");
+var br = tagFactory("br");
+var cite = tagFactory("cite");
+var code = tagFactory("code");
+var data = tagFactory("data");
+var dfn = tagFactory("dfn");
+var em = tagFactory("em");
+var i = tagFactory("i");
+var kbd = tagFactory("kbd");
+var mark = tagFactory("mark");
+var q = tagFactory("q");
+var rp = tagFactory("rp");
+var rt = tagFactory("rt");
+var ruby = tagFactory("ruby");
+var s = tagFactory("s");
+var samp = tagFactory("samp");
+var small = tagFactory("small");
+var strong = tagFactory("strong");
+var sub = tagFactory("sub");
+var sup = tagFactory("sup");
+var time = tagFactory("time");
+var u = tagFactory("u");
+var var_ = tagFactory("var");
+var area = tagFactory("area");
+var audio = tagFactory("audio");
+var img = tagFactory("img");
+var map = tagFactory("map");
+var track2 = tagFactory("track");
+var video = tagFactory("video");
+var embed = tagFactory("embed");
+var iframe = tagFactory("iframe");
+var object = tagFactory("object");
+var param = tagFactory("param");
+var picture = tagFactory("picture");
+var portal = tagFactory("portal");
+var source = tagFactory("source");
+var svg = tagFactory("svg", SVG_NS);
+var math = tagFactory("math");
+var canvas = tagFactory("canvas");
+var noscript = tagFactory("noscript");
+var script = tagFactory("script");
+var del = tagFactory("del");
+var ins = tagFactory("ins");
+var caption = tagFactory("caption");
+var col = tagFactory("col");
+var colgroup = tagFactory("colgroup");
+var table = tagFactory("table");
+var tbody = tagFactory("tbody");
+var td = tagFactory("td");
+var tfoot = tagFactory("tfoot");
+var th = tagFactory("th");
+var thead = tagFactory("thead");
+var tr = tagFactory("tr");
+var button = tagFactory("button");
+var datalist = tagFactory("datalist");
+var fieldset = tagFactory("fieldset");
+var form = tagFactory("form");
+var input = tagFactory("input");
+var label = tagFactory("label");
+var legend = tagFactory("legend");
+var meter = tagFactory("meter");
+var optgroup = tagFactory("optgroup");
+var option = tagFactory("option");
+var output = tagFactory("output");
+var progress = tagFactory("progress");
+var select = tagFactory("select");
+var textarea = tagFactory("textarea");
+var details = tagFactory("details");
+var dialog = tagFactory("dialog");
+var menu = tagFactory("menu");
+var summary = tagFactory("summary");
+var slot = tagFactory("slot");
+var template = tagFactory("template");
+var base = tagFactory("base");
+var link = tagFactory("link");
+var meta = tagFactory("meta");
+var style = tagFactory("style");
+var circle = tagFactory("circle", SVG_NS);
+var ellipse = tagFactory("ellipse", SVG_NS);
+var g = tagFactory("g", SVG_NS);
+var line = tagFactory("line", SVG_NS);
+var path = tagFactory("path", SVG_NS);
+var polygon = tagFactory("polygon", SVG_NS);
+var polyline = tagFactory("polyline", SVG_NS);
+var rect = tagFactory("rect", SVG_NS);
+var text = tagFactory("text", SVG_NS);
+var tspan = tagFactory("tspan", SVG_NS);
+var defs = tagFactory("defs", SVG_NS);
+var clipPath = tagFactory("clipPath", SVG_NS);
+var mask = tagFactory("mask", SVG_NS);
+var pattern = tagFactory("pattern", SVG_NS);
+var linearGradient = tagFactory("linearGradient", SVG_NS);
+var radialGradient = tagFactory("radialGradient", SVG_NS);
+var stop = tagFactory("stop", SVG_NS);
+var use = tagFactory("use", SVG_NS);
+var symbol = tagFactory("symbol", SVG_NS);
+var marker = tagFactory("marker", SVG_NS);
+var center = tagFactory("center");
+var font = tagFactory("font");
+var marquee = tagFactory("marquee");
+
+// src/platform/microfrontend.ts
+var moduleCache = /* @__PURE__ */ new Map();
+function createMicroApp(config) {
+  const host = config.container ?? document.createElement("div");
+  host.setAttribute("data-micro-app", config.name);
+  let root;
+  if (config.shadow) {
+    root = host.attachShadow({ mode: "open" });
+  } else {
+    root = host;
+  }
+  let mounted = false;
+  function mount(component) {
+    if (root instanceof ShadowRoot) {
+      root.innerHTML = "";
+    } else {
+      while (root.firstChild) {
+        root.removeChild(root.firstChild);
+      }
+    }
+    const el = component();
+    root.appendChild(el);
+    mounted = true;
+  }
+  function unmount() {
+    if (!mounted) return;
+    if (root instanceof ShadowRoot) {
+      root.innerHTML = "";
+    } else {
+      while (root.firstChild) {
+        root.removeChild(root.firstChild);
+      }
+    }
+    mounted = false;
+  }
+  return { mount, unmount, element: host };
+}
+function loadRemoteModule(url) {
+  const cached = moduleCache.get(url);
+  if (cached) return cached;
+  const promise = import(
+    /* @vite-ignore */
+    url
+  );
+  moduleCache.set(url, promise);
+  promise.catch(() => {
+    moduleCache.delete(url);
+  });
+  return promise;
+}
+function defineRemoteComponent(name, loader) {
+  let cached = null;
+  return function RemoteComponent() {
+    if (cached) {
+      return cached();
+    }
+    const container = div({
+      class: "sibu-remote",
+      "data-remote-component": name
+    });
+    container.appendChild(span({ class: "sibu-remote-loading", nodes: "Loading..." }));
+    loader().then((mod) => {
+      cached = mod.default;
+      const rendered = cached();
+      container.replaceChildren(rendered);
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      container.replaceChildren(
+        div({
+          class: "sibu-remote-error",
+          nodes: `Failed to load remote component "${name}": ${message}`
+        })
+      );
+    });
+    return container;
+  };
+}
+function createSharedScope(initialState) {
+  const signals = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(initialState)) {
+    const [get2, set2] = signal(initialState[key]);
+    signals.set(key, { get: get2, set: set2 });
+    subscribers.set(key, /* @__PURE__ */ new Set());
+  }
+  function ensureSignal(key) {
+    if (!signals.has(key)) {
+      const [get2, set2] = signal(void 0);
+      signals.set(key, { get: get2, set: set2 });
+      subscribers.set(key, /* @__PURE__ */ new Set());
+    }
+  }
+  function get(key) {
+    ensureSignal(key);
+    return signals.get(key)?.get();
+  }
+  function set(key, value) {
+    ensureSignal(key);
+    signals.get(key)?.set(value);
+    const subs = subscribers.get(key);
+    if (subs) {
+      for (const cb of subs) {
+        cb(value);
+      }
+    }
+  }
+  function subscribe(key, callback) {
+    ensureSignal(key);
+    const subs = subscribers.get(key);
+    if (!subs) {
+      return () => {
+      };
+    }
+    subs.add(callback);
+    return () => {
+      subs.delete(callback);
+    };
+  }
+  return { get, set, subscribe };
+}
+
+// src/platform/serviceWorker.ts
+function serviceWorker(scriptUrl, options) {
+  const [registration, setRegistration] = signal(null);
+  const [isReady, setIsReady] = signal(false);
+  const [isUpdateAvailable, setIsUpdateAvailable] = signal(false);
+  const [error, setError] = signal(null);
+  if ("serviceWorker" in navigator) {
+    navigator.serviceWorker.register(scriptUrl, options).then((reg) => {
+      setRegistration(reg);
+      setIsReady(true);
+      reg.addEventListener("updatefound", () => {
+        const newWorker = reg.installing;
+        if (newWorker) {
+          newWorker.addEventListener("statechange", () => {
+            if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
+              setIsUpdateAvailable(true);
+            }
+          });
+        }
+      });
+    }).catch((err) => {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  async function update() {
+    const reg = registration();
+    if (reg) {
+      await reg.update();
+    }
+  }
+  async function unregister() {
+    const reg = registration();
+    if (reg) {
+      const result = await reg.unregister();
+      if (result) {
+        setRegistration(null);
+        setIsReady(false);
+      }
+      return result;
+    }
+    return false;
+  }
+  return { registration, isReady, isUpdateAvailable, error, update, unregister };
+}
+
+// src/platform/worker.ts
+function worker(workerFn2) {
+  const [result, setResult] = signal(null);
+  const [error, setError] = signal(null);
+  const [loading, setLoading] = signal(false);
+  let worker2 = null;
+  try {
+    if (typeof Worker === "undefined") {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    const fnBody = workerFn2.toString();
+    const blob = new Blob([`self.onmessage = ${fnBody};`], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    worker2 = new Worker(url);
+    URL.revokeObjectURL(url);
+    worker2.onmessage = (e) => {
+      setResult(e.data);
+      setLoading(false);
+    };
+    worker2.onerror = (e) => {
+      setError(new Error(e.message || "Worker error"));
+      setLoading(false);
+    };
+  } catch (err) {
+    setError(err instanceof Error ? err : new Error(String(err)));
+  }
+  function post(data2) {
+    if (!worker2) return;
+    setLoading(true);
+    setError(null);
+    setResult(null);
+    worker2.postMessage(data2);
+  }
+  function terminate() {
+    if (!worker2) return;
+    worker2.terminate();
+    worker2 = null;
+    setLoading(false);
+  }
+  return { post, result, error, loading, terminate };
+}
+function workerFn(fn) {
+  const [loading, setLoading] = signal(false);
+  let worker2 = null;
+  try {
+    if (typeof Worker === "undefined") {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    const fnStr = fn.toString();
+    const blob = new Blob(
+      [
+        `self.onmessage = function(e) {
+  var fn = ${fnStr};
+  var result = fn.apply(null, e.data);
+  postMessage(result);
+};`
+      ],
+      { type: "application/javascript" }
+    );
+    const url = URL.createObjectURL(blob);
+    worker2 = new Worker(url);
+    URL.revokeObjectURL(url);
+  } catch {
+  }
+  function run(...args) {
+    return new Promise((resolve, reject) => {
+      if (!worker2) {
+        reject(new Error("Worker is not available"));
+        return;
+      }
+      setLoading(true);
+      worker2.onmessage = (e) => {
+        setLoading(false);
+        resolve(e.data);
+      };
+      worker2.onerror = (e) => {
+        setLoading(false);
+        reject(new Error(e.message || "Worker error"));
+      };
+      worker2.postMessage(args);
+    });
+  }
+  function terminate() {
+    if (!worker2) return;
+    worker2.terminate();
+    worker2 = null;
+    setLoading(false);
+  }
+  return { run, loading, terminate };
+}
+function createWorkerPool(workerFn2, poolSize) {
+  const size = poolSize || typeof navigator !== "undefined" && navigator.hardwareConcurrency || 4;
+  const workers = [];
+  let currentIndex = 0;
+  let alive = true;
+  try {
+    if (typeof Worker === "undefined") {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    const fnBody = workerFn2.toString();
+    const blob = new Blob([`self.onmessage = ${fnBody};`], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    for (let i2 = 0; i2 < size; i2++) {
+      workers.push(new Worker(url));
+    }
+    URL.revokeObjectURL(url);
+  } catch {
+  }
+  function execute(data2) {
+    return new Promise((resolve, reject) => {
+      if (!alive || workers.length === 0) {
+        reject(new Error("Worker pool is not available"));
+        return;
+      }
+      const worker2 = workers[currentIndex % workers.length];
+      currentIndex++;
+      worker2.onmessage = (e) => {
+        resolve(e.data);
+      };
+      worker2.onerror = (e) => {
+        reject(new Error(e.message || "Worker error"));
+      };
+      worker2.postMessage(data2);
+    });
+  }
+  function terminate() {
+    alive = false;
+    for (const w of workers) {
+      w.terminate();
+    }
+    workers.length = 0;
+  }
+  return { execute, terminate };
+}
+
+// src/platform/wasm.ts
+var moduleCache2 = /* @__PURE__ */ new Map();
+var instanceCache = /* @__PURE__ */ new Map();
+function wasm(source2, config = {}) {
+  const [instance, setInstance] = signal(null);
+  const [loading, setLoading] = signal(true);
+  const [error, setError] = signal(null);
+  const cacheKey = config.cacheKey || (typeof source2 === "string" ? source2 : void 0);
+  async function load() {
+    setLoading(true);
+    setError(null);
+    setInstance(null);
+    try {
+      const wasmInstance = await loadWasmModule(source2, config.imports, cacheKey);
+      setInstance(wasmInstance.exports);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }
+  load();
+  return {
+    instance,
+    loading,
+    error,
+    ready: () => instance() !== null,
+    reload: load
+  };
+}
+async function loadWasmModule(source2, imports, cacheKey) {
+  const key = cacheKey || (typeof source2 === "string" ? source2 : void 0);
+  if (key) {
+    const cachedInstance = instanceCache.get(key);
+    if (cachedInstance) {
+      return cachedInstance;
+    }
+  }
+  let module2;
+  const cachedModule = key ? moduleCache2.get(key) : void 0;
+  if (cachedModule) {
+    module2 = cachedModule;
+  } else {
+    let bytes;
+    if (typeof source2 === "string") {
+      if (typeof WebAssembly.instantiateStreaming === "function") {
+        const response2 = fetch(source2);
+        const result = await WebAssembly.instantiateStreaming(response2, imports || {});
+        if (key) {
+          moduleCache2.set(key, result.module);
+          instanceCache.set(key, result.instance);
+        }
+        return result.instance;
+      }
+      const response = await fetch(source2);
+      bytes = await response.arrayBuffer();
+    } else if (source2 instanceof Uint8Array) {
+      bytes = source2.buffer.slice(source2.byteOffset, source2.byteOffset + source2.byteLength);
+    } else {
+      bytes = source2;
+    }
+    module2 = await WebAssembly.compile(bytes);
+    if (key) moduleCache2.set(key, module2);
+  }
+  const instance = await WebAssembly.instantiate(module2, imports || {});
+  if (key) instanceCache.set(key, instance);
+  return instance;
+}
+async function preloadWasm(url) {
+  if (moduleCache2.has(url)) return;
+  let module2;
+  if (typeof WebAssembly.compileStreaming === "function") {
+    module2 = await WebAssembly.compileStreaming(fetch(url));
+  } else {
+    const response = await fetch(url);
+    const bytes = await response.arrayBuffer();
+    module2 = await WebAssembly.compile(bytes);
+  }
+  moduleCache2.set(url, module2);
+}
+function createWasmBridge(instance) {
+  const exports2 = instance.exports;
+  const memory = exports2.memory || instance.exports.memory;
+  return {
+    exports: instance.exports,
+    memory,
+    alloc(size) {
+      if (!exports2.malloc) throw new Error("WASM module does not export malloc");
+      return exports2.malloc(size);
+    },
+    free(ptr) {
+      if (!exports2.free) throw new Error("WASM module does not export free");
+      exports2.free(ptr);
+    },
+    writeString(str) {
+      const encoder = new TextEncoder();
+      const bytes = encoder.encode(str);
+      if (!exports2.malloc) throw new Error("WASM module does not export malloc");
+      const ptr = exports2.malloc(bytes.length);
+      new Uint8Array(memory.buffer, ptr, bytes.length).set(bytes);
+      return { ptr, len: bytes.length };
+    },
+    readString(ptr, len) {
+      const decoder = new TextDecoder();
+      return decoder.decode(new Uint8Array(memory.buffer, ptr, len));
+    },
+    writeArray(arr) {
+      if (!exports2.malloc) throw new Error("WASM module does not export malloc");
+      const ptr = exports2.malloc(arr.length * 8);
+      new Float64Array(memory.buffer, ptr, arr.length).set(Array.from(arr));
+      return { ptr, len: arr.length };
+    },
+    readF64Array(ptr, len) {
+      return new Float64Array(memory.buffer, ptr, len);
+    }
+  };
+}
+function clearWasmCache() {
+  moduleCache2.clear();
+  instanceCache.clear();
+}
+function isWasmCached(key) {
+  return moduleCache2.has(key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Head,
+  clearWasmCache,
+  collectStream,
+  composeMiddleware,
+  createAction,
+  createISR,
+  createMicroApp,
+  createMiddlewareChain,
+  createSharedScope,
+  createWasmBridge,
+  createWorkerPool,
+  defineRemoteComponent,
+  deserializeState,
+  generateStaticSite,
+  hydrate,
+  hydrateIslands,
+  hydrateProgressively,
+  isWasmCached,
+  island,
+  loadRemoteModule,
+  loadWasmModule,
+  preloadWasm,
+  renderToDocument,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  renderToSuspenseStream,
+  resetSSRState,
+  scrollRestoration,
+  serializeState,
+  serviceWorker,
+  setCanonical,
+  setStructuredData,
+  ssrSuspense,
+  suspenseSwapScript,
+  wasm,
+  worker,
+  workerFn
+});