@absolutejs/absolute 0.19.0-beta.694 → 0.19.0-beta.696

package/dist/svelte/server.js

@@ -78,99 +78,6 @@ var __legacyMetadataTS = (k, v) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/core/streamingSlotRegistrar.ts
-var STREAMING_SLOT_REGISTRAR_KEY, STREAMING_SLOT_WARNING_STORAGE_KEY, STREAMING_SLOT_COLLECTION_STORAGE_KEY, getRegisteredStreamingSlotRegistrar = () => {
-  const value = Reflect.get(globalThis, STREAMING_SLOT_REGISTRAR_KEY);
-  if (typeof value === "function" || value === null) {
-    return value;
-  }
-  return;
-}, isObjectRecord = (value) => Boolean(value) && typeof value === "object", isStreamingSlotWarningController = (value) => isObjectRecord(value) && ("maybeWarn" in value) && typeof value.maybeWarn === "function", isStreamingSlotCollectionController = (value) => isObjectRecord(value) && ("isCollecting" in value) && typeof value.isCollecting === "function", getWarningController = () => {
-  const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY);
-  if (value === null || typeof value === "undefined")
-    return;
-  return isStreamingSlotWarningController(value) ? value : undefined;
-}, getCollectionController = () => {
-  const value = Reflect.get(globalThis, STREAMING_SLOT_COLLECTION_STORAGE_KEY);
-  if (value === null || typeof value === "undefined")
-    return;
-  return isStreamingSlotCollectionController(value) ? value : undefined;
-}, hasRegisteredStreamingSlotRegistrar = () => typeof getRegisteredStreamingSlotRegistrar() === "function", isStreamingSlotCollectionActive = () => getCollectionController()?.isCollecting() === true, registerStreamingSlot = (slot) => {
-  getRegisteredStreamingSlotRegistrar()?.(slot);
-}, setStreamingSlotCollectionController = (controller) => {
-  Reflect.set(globalThis, STREAMING_SLOT_COLLECTION_STORAGE_KEY, controller);
-}, setStreamingSlotRegistrar = (nextRegistrar) => {
-  Reflect.set(globalThis, STREAMING_SLOT_REGISTRAR_KEY, nextRegistrar);
-}, setStreamingSlotWarningController = (controller) => {
-  Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY, controller);
-}, warnMissingStreamingSlotCollector = (primitiveName) => {
-  if (isStreamingSlotCollectionActive()) {
-    return;
-  }
-  getWarningController()?.maybeWarn(primitiveName);
-};
-var init_streamingSlotRegistrar = __esm(() => {
-  STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
-  STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
-  STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
-});
-
-// src/core/streamingSlotRegistry.ts
-var STREAMING_SLOT_STORAGE_KEY, isObjectRecord2 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", getStorageGlobal = () => {
-  const value = Reflect.get(globalThis, STREAMING_SLOT_STORAGE_KEY);
-  if (value === null || typeof value === "undefined") {
-    return value;
-  }
-  return isAsyncLocalStorage(value) ? value : undefined;
-}, isServerRuntime = () => typeof process !== "undefined" && typeof process.versions?.node === "string", ensureAsyncLocalStorage = async () => {
-  const storage = getStorageGlobal();
-  if (typeof storage !== "undefined") {
-    return storage;
-  }
-  if (!isServerRuntime()) {
-    Reflect.set(globalThis, STREAMING_SLOT_STORAGE_KEY, null);
-    return getStorageGlobal();
-  }
-  const mod = await import("async_hooks");
-  Reflect.set(globalThis, STREAMING_SLOT_STORAGE_KEY, new mod.AsyncLocalStorage);
-  return getStorageGlobal();
-}, getActiveSlotStore = () => {
-  const storage = getStorageGlobal();
-  if (!storage)
-    return;
-  return storage.getStore();
-}, registerStreamingSlot2 = (slot) => {
-  const store = getActiveSlotStore();
-  if (!store)
-    return;
-  store.set(slot.id, slot);
-}, hasActiveStreamingSlotRegistry = () => getActiveSlotStore() !== undefined, runWithStreamingSlotRegistry = async (task) => {
-  const storage = await ensureAsyncLocalStorage();
-  if (!storage) {
-    const slots = [];
-    return {
-      result: await task(),
-      slots
-    };
-  }
-  return storage.run(new Map, async () => {
-    const result = await task();
-    const store = storage.getStore();
-    return {
-      result,
-      slots: store ? [...store.values()] : []
-    };
-  });
-};
-var init_streamingSlotRegistry = __esm(() => {
-  init_streamingSlotRegistrar();
-  STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
-  setStreamingSlotRegistrar(registerStreamingSlot2);
-  setStreamingSlotCollectionController({
-    isCollecting: () => getActiveSlotStore() !== undefined
-  });
-});
-
 // src/build/resolvePackageImport.ts
 import { resolve, join } from "path";
 import { existsSync, readFileSync } from "fs";
@@ -359,12 +266,27 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/build/stylePreprocessor.ts
+var exports_stylePreprocessor = {};
+__export(exports_stylePreprocessor, {
+  stylePreprocessorPlugin: () => stylePreprocessorPlugin,
+  isStylePath: () => isStylePath,
+  isStyleModulePath: () => isStyleModulePath,
+  isPreprocessableStylePath: () => isPreprocessableStylePath,
+  getStyleBaseName: () => getStyleBaseName,
+  getCssOutputExtension: () => getCssOutputExtension,
+  createSvelteStylePreprocessor: () => createSvelteStylePreprocessor,
+  createStyleTransformConfig: () => createStyleTransformConfig,
+  createStylePreprocessorPlugin: () => createStylePreprocessorPlugin,
+  compileStyleSource: () => compileStyleSource,
+  compileStyleFileIfNeededSync: () => compileStyleFileIfNeededSync,
+  compileStyleFileIfNeeded: () => compileStyleFileIfNeeded
+});
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import { dirname, extname, isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
-var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
+var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
   const normalized = filePathOrLanguage.toLowerCase();
   if (normalized === "scss" || normalized.endsWith(".scss"))
     return "scss";
@@ -375,7 +297,13 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
   if (normalized === "styl" || normalized === "stylus" || normalized.endsWith(".styl") || normalized.endsWith(".stylus"))
     return "stylus";
   return null;
-}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), normalizeLoadPaths = (filePath, paths = []) => [
+}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), requireOptionalPeerSync = (specifier) => {
+  try {
+    return requireFromCwd(specifier);
+  } catch {
+    return requireOptionalPeer(specifier);
+  }
+}, normalizeLoadPaths = (filePath, paths = []) => [
   dirname(filePath),
   process.cwd(),
   ...paths.map((path) => resolve2(process.cwd(), path))
@@ -504,8 +432,72 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
 }, getSassOptions = (config, language) => ({
   ...config?.sass ?? {},
   ...language === "scss" ? config?.scss ?? {} : {}
-}), getLessOptions = (config) => config?.less ?? {}, getStylusOptions = (config) => config?.stylus ?? {}, withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
-${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, config) => ({
+}), getLessOptions = (config) => config?.less ?? {}, getStylusOptions = (config) => config?.stylus ?? {}, createStyleTransformConfig = (stylePreprocessors, postcss) => postcss === undefined ? stylePreprocessors : { ...stylePreprocessors ?? {}, postcss }, withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
+${contents}` : contents, normalizePostcssModule = (mod) => {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    return mod.default ?? mod;
+  }
+  return mod;
+}, loadPostcssConfigFile = async (configPath) => {
+  const resolved = resolve2(process.cwd(), configPath);
+  const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
+  const config = normalizePostcssModule(loaded);
+  const value = typeof config === "function" ? await config({
+    cwd: process.cwd(),
+    env: "development"
+  }) : config;
+  return normalizePostcssModule(value) ?? {};
+}, normalizePostcssPlugins = (plugins) => {
+  if (!plugins)
+    return [];
+  if (Array.isArray(plugins))
+    return plugins.filter(Boolean);
+  const resolved = [];
+  for (const [specifier, options] of Object.entries(plugins)) {
+    if (options === false)
+      continue;
+    const mod = normalizePostcssModule(requireOptionalPeerSync(specifier));
+    const plugin = typeof mod === "function" ? mod(options === true ? undefined : options) : mod;
+    if (plugin)
+      resolved.push(plugin);
+  }
+  return resolved;
+}, resolvePostcssConfig = async (config) => {
+  const inlineConfig = config?.postcss;
+  if (!inlineConfig)
+    return null;
+  const fileConfig = inlineConfig.config ? await loadPostcssConfigFile(inlineConfig.config) : {};
+  const plugins = [
+    ...normalizePostcssPlugins(fileConfig.plugins),
+    ...normalizePostcssPlugins(inlineConfig.plugins)
+  ];
+  if (plugins.length === 0)
+    return null;
+  return {
+    options: {
+      ...fileConfig.options ?? {},
+      ...inlineConfig.options ?? {}
+    },
+    plugins
+  };
+}, runPostcss = async (css, filePath, config) => {
+  const postcssConfig = await resolvePostcssConfig(config);
+  if (!postcssConfig)
+    return css;
+  let postcssModule;
+  try {
+    postcssModule = await importOptionalPeer("postcss");
+  } catch {
+    throw missingDependencyError("postcss", filePath);
+  }
+  const postcss = postcssModule.default ?? postcssModule;
+  const result = await postcss(postcssConfig.plugins).process(css, {
+    from: filePath,
+    map: false,
+    ...postcssConfig.options
+  });
+  return result.css;
+}, createSassImporter = (entryFile, loadPaths, language, config) => ({
   canonicalize(specifier, options) {
     const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
@@ -584,7 +576,7 @@ ${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, c
       syntax: language === "sass" ? "indented" : "scss",
       url: new URL(`file://${filePath}`)
     });
-    return result.css;
+    return runPostcss(result.css, filePath, config);
   }
   if (language === "less") {
     const options = getLessOptions(config);
@@ -609,15 +601,15 @@ ${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, c
         createLessFileManager(filePath, loadPaths, config)
       ]
     });
-    return result.css;
+    return runPostcss(result.css, filePath, config);
   }
   if (language === "stylus") {
     const options = getStylusOptions(config);
     const loadPaths = normalizeLoadPaths(filePath, options.paths);
     const contents = withAdditionalData(preprocessLoadedStyle(rawContents, filePath, filePath, loadPaths, "stylus", config), options.additionalData);
-    return renderStylus(contents, filePath, loadPaths, options);
+    return runPostcss(await renderStylus(contents, filePath, loadPaths, options), filePath, config);
   }
-  return rawContents;
+  return runPostcss(rawContents, filePath, config);
 }, createStylePreprocessorPlugin = (config) => ({
   name: "absolute-style-preprocessor",
   setup(build) {
@@ -653,6 +645,10 @@ ${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, c
         loader: "css"
       };
     });
+    build.onLoad({ filter: CSS_EXTENSION_PATTERN }, async ({ path }) => ({
+      contents: await compileStyleSource(path, undefined, undefined, config),
+      loader: "css"
+    }));
   }
 }), stylePreprocessorPlugin, createSvelteStylePreprocessor = (config) => ({
   style: async ({
@@ -670,11 +666,46 @@ ${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, c
   }
 }), compileStyleFileIfNeeded = async (filePath, config) => {
   if (!isPreprocessableStylePath(filePath)) {
-    return readFile(filePath, "utf-8");
+    return runPostcss(await readFile(filePath, "utf-8"), filePath, config);
   }
   return compileStyleSource(filePath, undefined, undefined, config);
-};
+}, compileStyleFileIfNeededSync = (filePath, config) => {
+  const rawContents = readFileSync2(filePath, "utf-8");
+  const language = getStyleLanguage(filePath);
+  if (config?.postcss) {
+    throw new Error(`Unable to compile ${filePath}: PostCSS preprocessing is async-only.`);
+  }
+  if (language === "scss" || language === "sass") {
+    const options = getSassOptions(config, language);
+    const packageName = options.implementation ?? "sass";
+    let sass;
+    try {
+      sass = requireOptionalPeerSync(packageName);
+    } catch {
+      throw missingDependencyError(packageName, filePath);
+    }
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
+    return sass.compileString(contents, {
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
+      style: "expanded",
+      syntax: language === "sass" ? "indented" : "scss",
+      url: new URL(`file://${filePath}`)
+    }).css;
+  }
+  if (language === "less") {
+    throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  if (language === "stylus") {
+    throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  return rawContents;
+}, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
+  CSS_EXTENSION_PATTERN = /\.css$/i;
   STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less|styl(?:us)?)$/i;
   STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
@@ -864,305 +895,107 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
-// src/core/islandPageContext.ts
-var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient", ISLAND_MARKER = 'data-island="true"', MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__", ISLAND_STATE_MARKER = "__ABS_ISLAND_STATE__", CLOSING_HEAD_TAG = "</head>", buildIslandsHeadMarkup = (manifest) => {
-  const manifestScript = `<script>window.__ABSOLUTE_MANIFEST__ = ${JSON.stringify(manifest)}</script>`;
-  const islandStateScript = `<script>window.__ABS_ISLAND_STATE__ = ${JSON.stringify(globalThis.__ABS_ISLAND_STATE__ ?? {})}</script>`;
-  const bootstrapPath = manifest[BOOTSTRAP_MANIFEST_KEY];
-  const bootstrapScript = bootstrapPath ? `<script type="module" src="${bootstrapPath}"></script>` : "";
-  return `${manifestScript}${islandStateScript}${bootstrapScript}`;
-}, injectHeadMarkup = (html, markup) => {
-  const closingHeadIndex = html.indexOf("</head>");
-  if (closingHeadIndex >= 0) {
-    return `${html.slice(0, closingHeadIndex)}${markup}${html.slice(closingHeadIndex)}`;
+// src/core/devRouteRegistrationCallsite.ts
+var exports_devRouteRegistrationCallsite = {};
+__export(exports_devRouteRegistrationCallsite, {
+  patchElysiaRouteRegistrationCallsites: () => patchElysiaRouteRegistrationCallsites,
+  getCurrentRouteRegistrationCallsite: () => getCurrentRouteRegistrationCallsite
+});
+import { AsyncLocalStorage } from "async_hooks";
+import { Elysia } from "elysia";
+var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, isObjectRecord3 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage2 = (value) => isObjectRecord3(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", getRouteCallsiteStorage = () => {
+  const value = Reflect.get(globalThis, ROUTE_CALLSITE_STORAGE_KEY);
+  if (value === null || typeof value === "undefined") {
+    return;
   }
-  const openingBodyIndex = html.indexOf("<body");
-  if (openingBodyIndex >= 0) {
-    const bodyStart = html.indexOf(">", openingBodyIndex);
-    if (bodyStart >= 0) {
-      return `${html.slice(0, openingBodyIndex)}<head>${markup}</head>${html.slice(openingBodyIndex)}`;
+  return isAsyncLocalStorage2(value) ? value : undefined;
+}, ensureRouteCallsiteStorage = () => {
+  const existing = getRouteCallsiteStorage();
+  if (existing) {
+    return existing;
+  }
+  const storage = new AsyncLocalStorage;
+  Reflect.set(globalThis, ROUTE_CALLSITE_STORAGE_KEY, storage);
+  return storage;
+}, normalizeCallsitePath = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, ""), extractRouteRegistrationCallsite = (stack) => {
+  const frames = stack.split(`
+`).slice(1).map((line) => line.trim());
+  for (const frame of frames) {
+    if (frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/core/devRouteRegistrationCallsite.")) {
+      continue;
+    }
+    const locationMatch = frame.match(/\((\/[^)]+:\d+:\d+)\)$/) ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/);
+    if (locationMatch?.[1]) {
+      return normalizeCallsitePath(locationMatch[1]);
     }
   }
-  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
-}, streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true }), flushSafePendingText = (controller, encoder, pending, lookbehind) => {
-  if (pending.length <= lookbehind) {
-    return pending;
+  return;
+}, captureRouteRegistrationCallsite = () => {
+  const { stack } = new Error;
+  if (!stack) {
+    return;
   }
-  const safeText = pending.slice(0, pending.length - lookbehind);
-  controller.enqueue(encoder.encode(safeText));
-  return pending.slice(-lookbehind);
-}, updateInjectedState = (consumed, injected, pending) => {
-  if (consumed.done) {
-    return { done: true, injected, pending };
+  return extractRouteRegistrationCallsite(stack);
+}, wrapRouteHandlerWithCallsite = (handler, callsite) => {
+  if (typeof handler !== "function" || !callsite) {
+    return handler;
   }
-  return {
-    done: false,
-    injected: consumed.injected,
-    pending: consumed.pending
+  const storage = ensureRouteCallsiteStorage();
+  return function wrappedRouteHandler(...args) {
+    return storage.run({ callsite }, () => Reflect.apply(handler, this, args));
   };
-}, readStreamChunk = async (reader) => {
-  const { done, value } = await reader.read();
-  if (done || !value) {
-    return { done, value: undefined };
+}, getCurrentRouteRegistrationCallsite = () => getRouteCallsiteStorage()?.getStore()?.callsite, patchElysiaRouteRegistrationCallsites = () => {
+  if (false) {}
+  if (Reflect.get(globalThis, ROUTE_CALLSITE_PATCHED_KEY) === true) {
+    return;
   }
-  return { done, value };
-}, pipeStreamWithHeadInjection = (stream, markup) => {
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const lookbehind = CLOSING_HEAD_TAG.length - 1;
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
-    }
-    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
-    if (headIndex >= 0) {
-      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
+  const prototype = Elysia.prototype;
+  for (const methodName of ROUTE_METHOD_NAMES) {
+    const originalMethod = prototype[methodName];
+    if (typeof originalMethod !== "function") {
+      continue;
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    prototype[methodName] = function patchedRouteMethod(path, handler, ...rest) {
+      const callsite = captureRouteRegistrationCallsite();
+      return Reflect.apply(originalMethod, this, [
+        path,
+        wrapRouteHandlerWithCallsite(handler, callsite),
+        ...rest
+      ]);
     };
-  };
-  const finishHeadInjectionStream = (controller, pending, injected) => {
-    let finalPending = pending + decoder.decode();
-    if (!injected) {
-      finalPending = injectHeadMarkup(finalPending, markup);
-    }
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
-    }
-    controller.close();
-  };
-  const consumeHeadChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
-    }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
-  };
-  const runHeadInjectionLoop = async (controller, reader) => {
-    const consumeNextHeadChunk = async (injected, pending) => {
-      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
-      }
-      return consumeNextHeadChunk(nextState.injected, nextState.pending);
-    };
-    return consumeNextHeadChunk(false, "");
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      try {
-        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
-        finishHeadInjectionStream(controller, pending, injected);
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-}, pipeStreamWithIslandMarkerDetection = (stream, markup) => {
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
-    }
-    const markerIndex = pending.indexOf(ISLAND_MARKER);
-    if (markerIndex >= 0) {
-      const tagStart = pending.lastIndexOf("<", markerIndex);
-      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
-      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
-    }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
-  };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
-    }
-    controller.close();
-  };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
-    }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
-  };
-  const runIslandMarkerLoop = async (controller, reader) => {
-    const consumeNextIslandChunk = async (injected, pending) => {
-      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
-      }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
-    };
-    return consumeNextIslandChunk(false, "");
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-}, htmlContainsIslands = (html) => html.includes(ISLAND_MARKER), injectIslandPageContext = (html, options) => {
-  const manifest = globalThis.__absoluteManifest;
-  const hasIslands = options?.hasIslands ?? htmlContainsIslands(html);
-  if (!manifest || !hasIslands) {
-    return html;
-  }
-  if (html.includes(MANIFEST_MARKER) || html.includes(ISLAND_STATE_MARKER)) {
-    return html;
-  }
-  return injectHeadMarkup(html, buildIslandsHeadMarkup(manifest));
-}, injectIslandPageContextStream = (stream, options) => {
-  const manifest = globalThis.__absoluteManifest;
-  if (!manifest)
-    return stream;
-  const markup = buildIslandsHeadMarkup(manifest);
-  if (options?.hasIslands === true) {
-    return pipeStreamWithHeadInjection(stream, markup);
-  }
-  if (options?.hasIslands === false) {
-    return stream;
-  }
-  return pipeStreamWithIslandMarkerDetection(stream, markup);
-}, setCurrentIslandManifest = (manifest) => {
-  globalThis.__absoluteManifest = manifest;
-};
-var init_islandPageContext = __esm(() => {
-  init_constants();
-});
-
-// src/core/devRouteRegistrationCallsite.ts
-var exports_devRouteRegistrationCallsite = {};
-__export(exports_devRouteRegistrationCallsite, {
-  patchElysiaRouteRegistrationCallsites: () => patchElysiaRouteRegistrationCallsites,
-  getCurrentRouteRegistrationCallsite: () => getCurrentRouteRegistrationCallsite
-});
-import { AsyncLocalStorage } from "async_hooks";
-import { Elysia } from "elysia";
-var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, isObjectRecord3 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage2 = (value) => isObjectRecord3(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", getRouteCallsiteStorage = () => {
-  const value = Reflect.get(globalThis, ROUTE_CALLSITE_STORAGE_KEY);
-  if (value === null || typeof value === "undefined") {
-    return;
-  }
-  return isAsyncLocalStorage2(value) ? value : undefined;
-}, ensureRouteCallsiteStorage = () => {
-  const existing = getRouteCallsiteStorage();
-  if (existing) {
-    return existing;
-  }
-  const storage = new AsyncLocalStorage;
-  Reflect.set(globalThis, ROUTE_CALLSITE_STORAGE_KEY, storage);
-  return storage;
-}, normalizeCallsitePath = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, ""), extractRouteRegistrationCallsite = (stack) => {
-  const frames = stack.split(`
-`).slice(1).map((line) => line.trim());
-  for (const frame of frames) {
-    if (frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/core/devRouteRegistrationCallsite.")) {
-      continue;
-    }
-    const locationMatch = frame.match(/\((\/[^)]+:\d+:\d+)\)$/) ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/);
-    if (locationMatch?.[1]) {
-      return normalizeCallsitePath(locationMatch[1]);
-    }
-  }
-  return;
-}, captureRouteRegistrationCallsite = () => {
-  const { stack } = new Error;
-  if (!stack) {
-    return;
-  }
-  return extractRouteRegistrationCallsite(stack);
-}, wrapRouteHandlerWithCallsite = (handler, callsite) => {
-  if (typeof handler !== "function" || !callsite) {
-    return handler;
-  }
-  const storage = ensureRouteCallsiteStorage();
-  return function wrappedRouteHandler(...args) {
-    return storage.run({ callsite }, () => Reflect.apply(handler, this, args));
-  };
-}, getCurrentRouteRegistrationCallsite = () => getRouteCallsiteStorage()?.getStore()?.callsite, patchElysiaRouteRegistrationCallsites = () => {
-  if (false) {}
-  if (Reflect.get(globalThis, ROUTE_CALLSITE_PATCHED_KEY) === true) {
-    return;
-  }
-  const prototype = Elysia.prototype;
-  for (const methodName of ROUTE_METHOD_NAMES) {
-    const originalMethod = prototype[methodName];
-    if (typeof originalMethod !== "function") {
-      continue;
-    }
-    prototype[methodName] = function patchedRouteMethod(path, handler, ...rest) {
-      const callsite = captureRouteRegistrationCallsite();
-      return Reflect.apply(originalMethod, this, [
-        path,
-        wrapRouteHandlerWithCallsite(handler, callsite),
-        ...rest
-      ]);
-    };
-  }
-  Reflect.set(globalThis, ROUTE_CALLSITE_PATCHED_KEY, true);
-};
-var init_devRouteRegistrationCallsite = __esm(() => {
-  ROUTE_CALLSITE_STORAGE_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsiteStorage");
-  ROUTE_CALLSITE_PATCHED_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsitePatched");
-  ROUTE_METHOD_NAMES = [
-    "all",
-    "delete",
-    "get",
-    "head",
-    "options",
-    "patch",
-    "post",
-    "put"
-  ];
-});
-
-// src/client/streamSwap.ts
-var streamSwapRuntime = () => {
-  const SLOT_PATCH_EVENT = "absolutejs:slot-patch";
-  if (window.__ABS_SLOT_RUNTIME__ === true)
-    return;
-  window.__ABS_SLOT_RUNTIME__ = true;
-  window.__ABS_SLOT_CONSUMERS__ = window.__ABS_SLOT_CONSUMERS__ ?? {};
-  window.__ABS_SLOT_PENDING__ = window.__ABS_SLOT_PENDING__ ?? {};
-  const consumers = window.__ABS_SLOT_CONSUMERS__;
-  const pending = window.__ABS_SLOT_PENDING__;
-  const isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
-  const isPatchedPendingEntry = (value) => {
-    if (!isObjectRecord4(value))
-      return false;
-    return value.domPatched === true && "payload" in value;
+  }
+  Reflect.set(globalThis, ROUTE_CALLSITE_PATCHED_KEY, true);
+};
+var init_devRouteRegistrationCallsite = __esm(() => {
+  ROUTE_CALLSITE_STORAGE_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsiteStorage");
+  ROUTE_CALLSITE_PATCHED_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsitePatched");
+  ROUTE_METHOD_NAMES = [
+    "all",
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put"
+  ];
+});
+
+// src/client/streamSwap.ts
+var streamSwapRuntime = () => {
+  const SLOT_PATCH_EVENT = "absolutejs:slot-patch";
+  if (window.__ABS_SLOT_RUNTIME__ === true)
+    return;
+  window.__ABS_SLOT_RUNTIME__ = true;
+  window.__ABS_SLOT_CONSUMERS__ = window.__ABS_SLOT_CONSUMERS__ ?? {};
+  window.__ABS_SLOT_PENDING__ = window.__ABS_SLOT_PENDING__ ?? {};
+  const consumers = window.__ABS_SLOT_CONSUMERS__;
+  const pending = window.__ABS_SLOT_PENDING__;
+  const isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
+  const isPatchedPendingEntry = (value) => {
+    if (!isObjectRecord4(value))
+      return false;
+    return value.domPatched === true && "payload" in value;
   };
   const unwrapPendingPayload = (value) => isPatchedPendingEntry(value) ? value.payload : value;
   const canApplyImmediately = () => window.__ABS_SLOT_HYDRATION_PENDING__ !== true;
@@ -1824,41 +1657,586 @@ var init_streamingSlots = __esm(() => {
   };
 });
 
-// src/core/responseEnhancers.ts
-var toResponse = async (responseLike) => responseLike, cloneHeaders = (response) => {
-  const headers = new Headers(response.headers);
-  return headers;
-}, enhanceHtmlResponseWithStreamingSlots = (response, {
-  nonce,
-  onError,
-  runtimePlacement,
-  runtimePreludeScript,
-  streamingSlots = [],
-  policy
-} = {}) => {
-  if (!response.body || streamingSlots.length === 0) {
-    return response;
+// src/utils/getDurationString.ts
+var getDurationString = (duration) => {
+  let durationString;
+  if (duration < MILLISECONDS_IN_A_SECOND) {
+    durationString = `${duration.toFixed(TIME_PRECISION)}ms`;
+  } else if (duration < MILLISECONDS_IN_A_MINUTE) {
+    durationString = `${(duration / MILLISECONDS_IN_A_SECOND).toFixed(TIME_PRECISION)}s`;
+  } else {
+    durationString = `${(duration / MILLISECONDS_IN_A_MINUTE).toFixed(TIME_PRECISION)}m`;
   }
-  const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
-    nonce,
-    onError,
-    policy,
-    runtimePlacement,
-    runtimePreludeScript
-  });
+  return durationString;
+};
+var init_getDurationString = __esm(() => {
+  init_constants();
+});
+
+// src/utils/startupBanner.ts
+var colors, MONTHS, formatTimestamp = () => {
+  const now = new Date;
+  const month = MONTHS[now.getMonth()];
+  const day = now.getDate().toString().padStart(2, "0");
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, "0");
+  const seconds = now.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= HOURS_IN_HALF_DAY ? "PM" : "AM";
+  hours = hours % HOURS_IN_HALF_DAY || HOURS_IN_HALF_DAY;
+  return `${month} ${day} ${hours}:${minutes}:${seconds} ${ampm}`;
+}, startupBanner = (options) => {
+  const {
+    version,
+    readyDuration,
+    buildDuration,
+    port,
+    host,
+    networkUrl,
+    protocol = "http"
+  } = options;
+  const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
+  const ver = `${colors.dim}v${version}${colors.reset}`;
+  const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(readyDuration)}${colors.reset}`;
+  const build = typeof buildDuration === "number" && Number.isFinite(buildDuration) ? ` ${colors.dim}(build ${getDurationString(buildDuration)})${colors.reset}` : "";
+  console.log("");
+  console.log(`  ${name} ${ver}  ${time}${build}`);
+  console.log("");
+  console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   ${protocol}://${host === "0.0.0.0" ? "localhost" : host}:${port}/`);
+  if (networkUrl) {
+    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
+  }
+  console.log("");
+};
+var init_startupBanner = __esm(() => {
+  init_constants();
+  init_getDurationString();
+  colors = {
+    bold: "\x1B[1m",
+    cyan: "\x1B[36m",
+    dim: "\x1B[2m",
+    green: "\x1B[32m",
+    reset: "\x1B[0m"
+  };
+  MONTHS = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+});
+
+// src/utils/logger.ts
+var colors2, frameworkColors, formatPath = (filePath) => {
+  const cwd = process.cwd();
+  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative3 = relative3.replace(/\\/g, "/");
+  if (!relative3.startsWith("/")) {
+    relative3 = `/${relative3}`;
+  }
+  return relative3;
+}, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
+  let message = action;
+  if (options?.path) {
+    const pathColor = options.framework ? getFrameworkColor(options.framework) : colors2.white;
+    message += ` ${pathColor}${formatPath(options.path)}${colors2.reset}`;
+  }
+  if (options?.duration !== undefined) {
+    message += ` ${colors2.dim}(${options.duration}ms)${colors2.reset}`;
+  }
+  console.log(`${timestamp} ${tag} ${message}`);
+}, logCssUpdate = (path, framework, duration) => {
+  log("css update", { duration, framework: framework ?? "css", path });
+}, logError = (message, error) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.red}[hmr]${colors2.reset}`;
+  const errorMsg = error instanceof Error ? error.message : error;
+  const fullMessage = `${colors2.red}error${colors2.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
+  console.error(`${timestamp} ${tag} ${fullMessage}`);
+}, logHmrUpdate = (path, framework, duration) => {
+  log("hmr update", { duration, framework, path });
+}, logScriptUpdate = (path, framework, duration) => {
+  log("script update", { duration, framework, path });
+}, logServerReload = () => {
+  log(`${colors2.cyan}server module reloaded${colors2.reset}`);
+}, logWarn = (message) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.yellow}[hmr]${colors2.reset}`;
+  console.log(`${timestamp} ${tag} ${colors2.yellow}warning ${message}${colors2.reset}`);
+};
+var init_logger = __esm(() => {
+  init_startupBanner();
+  colors2 = {
+    blue: "\x1B[34m",
+    bold: "\x1B[1m",
+    cyan: "\x1B[36m",
+    dim: "\x1B[2m",
+    green: "\x1B[32m",
+    magenta: "\x1B[35m",
+    red: "\x1B[31m",
+    reset: "\x1B[0m",
+    white: "\x1B[37m",
+    yellow: "\x1B[33m"
+  };
+  frameworkColors = {
+    angular: colors2.magenta,
+    assets: colors2.dim,
+    css: colors2.cyan,
+    html: colors2.white,
+    htmx: colors2.white,
+    react: colors2.blue,
+    svelte: colors2.yellow,
+    vue: colors2.green
+  };
+});
+
+// src/core/ssrCache.ts
+var dirtyFrameworks, markSsrCacheDirty = (framework) => {
+  dirtyFrameworks.add(framework);
+}, isSsrCacheDirty = (framework) => dirtyFrameworks.has(framework);
+var init_ssrCache = __esm(() => {
+  dirtyFrameworks = new Set;
+});
+
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+}, toScreamingSnake = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+
+// src/svelte/renderToReadableStream.ts
+var exports_renderToReadableStream = {};
+__export(exports_renderToReadableStream, {
+  renderToReadableStream: () => renderToReadableStream,
+  SVELTE_PAGE_ROOT_ID: () => SVELTE_PAGE_ROOT_ID
+});
+var SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__", renderToReadableStream = async (component, props, {
+  bootstrapScriptContent,
+  bootstrapScripts = [],
+  bootstrapModules = [],
+  nonce,
+  onError = console.error,
+  progressiveChunkSize = DEFAULT_CHUNK_SIZE,
+  signal,
+  headContent,
+  bodyContent
+} = {}) => {
+  try {
+    const { render } = await import("svelte/server");
+    const rendered = typeof props === "undefined" ? await render(component) : await render(component, { props });
+    const { head, body } = rendered;
+    const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
+    const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
+    const encoder = new TextEncoder;
+    const full = encoder.encode(`<!DOCTYPE html><html lang="en"><head>${head}${headContent ?? ""}</head><body><div id="${SVELTE_PAGE_ROOT_ID}">${body}</div>${scripts}${bodyContent ?? ""}</body></html>`);
+    let offset = 0;
+    return new ReadableStream({
+      type: "bytes",
+      cancel(reason) {
+        onError?.(reason);
+      },
+      pull(controller) {
+        if (signal?.aborted) {
+          controller.close();
+          return;
+        }
+        if (offset >= full.length) {
+          controller.close();
+          return;
+        }
+        const end = Math.min(offset + progressiveChunkSize, full.length);
+        controller.enqueue(full.subarray(offset, end));
+        offset = end;
+      }
+    });
+  } catch (error) {
+    onError?.(error);
+    throw error;
+  }
+};
+var init_renderToReadableStream = __esm(() => {
+  init_constants();
+  init_escapeScriptContent();
+});
+
+// src/core/streamingSlotRegistrar.ts
+var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
+var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
+var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
+var getRegisteredStreamingSlotRegistrar = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_REGISTRAR_KEY);
+  if (typeof value === "function" || value === null) {
+    return value;
+  }
+  return;
+};
+var isObjectRecord = (value) => Boolean(value) && typeof value === "object";
+var isStreamingSlotWarningController = (value) => isObjectRecord(value) && ("maybeWarn" in value) && typeof value.maybeWarn === "function";
+var isStreamingSlotCollectionController = (value) => isObjectRecord(value) && ("isCollecting" in value) && typeof value.isCollecting === "function";
+var getWarningController = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY);
+  if (value === null || typeof value === "undefined")
+    return;
+  return isStreamingSlotWarningController(value) ? value : undefined;
+};
+var getCollectionController = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_COLLECTION_STORAGE_KEY);
+  if (value === null || typeof value === "undefined")
+    return;
+  return isStreamingSlotCollectionController(value) ? value : undefined;
+};
+var hasRegisteredStreamingSlotRegistrar = () => typeof getRegisteredStreamingSlotRegistrar() === "function";
+var isStreamingSlotCollectionActive = () => getCollectionController()?.isCollecting() === true;
+var registerStreamingSlot = (slot) => {
+  getRegisteredStreamingSlotRegistrar()?.(slot);
+};
+var setStreamingSlotCollectionController = (controller) => {
+  Reflect.set(globalThis, STREAMING_SLOT_COLLECTION_STORAGE_KEY, controller);
+};
+var setStreamingSlotRegistrar = (nextRegistrar) => {
+  Reflect.set(globalThis, STREAMING_SLOT_REGISTRAR_KEY, nextRegistrar);
+};
+var setStreamingSlotWarningController = (controller) => {
+  Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY, controller);
+};
+var warnMissingStreamingSlotCollector = (primitiveName) => {
+  if (isStreamingSlotCollectionActive()) {
+    return;
+  }
+  getWarningController()?.maybeWarn(primitiveName);
+};
+
+// src/core/streamingSlotRegistry.ts
+var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
+var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
+var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getStorageGlobal = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_STORAGE_KEY);
+  if (value === null || typeof value === "undefined") {
+    return value;
+  }
+  return isAsyncLocalStorage(value) ? value : undefined;
+};
+var isServerRuntime = () => typeof process !== "undefined" && typeof process.versions?.node === "string";
+var ensureAsyncLocalStorage = async () => {
+  const storage = getStorageGlobal();
+  if (typeof storage !== "undefined") {
+    return storage;
+  }
+  if (!isServerRuntime()) {
+    Reflect.set(globalThis, STREAMING_SLOT_STORAGE_KEY, null);
+    return getStorageGlobal();
+  }
+  const mod = await import("async_hooks");
+  Reflect.set(globalThis, STREAMING_SLOT_STORAGE_KEY, new mod.AsyncLocalStorage);
+  return getStorageGlobal();
+};
+var getActiveSlotStore = () => {
+  const storage = getStorageGlobal();
+  if (!storage)
+    return;
+  return storage.getStore();
+};
+var registerStreamingSlot2 = (slot) => {
+  const store = getActiveSlotStore();
+  if (!store)
+    return;
+  store.set(slot.id, slot);
+};
+setStreamingSlotRegistrar(registerStreamingSlot2);
+setStreamingSlotCollectionController({
+  isCollecting: () => getActiveSlotStore() !== undefined
+});
+var hasActiveStreamingSlotRegistry = () => getActiveSlotStore() !== undefined;
+var runWithStreamingSlotRegistry = async (task) => {
+  const storage = await ensureAsyncLocalStorage();
+  if (!storage) {
+    const slots = [];
+    return {
+      result: await task(),
+      slots
+    };
+  }
+  return storage.run(new Map, async () => {
+    const result = await task();
+    const store = storage.getStore();
+    return {
+      result,
+      slots: store ? [...store.values()] : []
+    };
+  });
+};
+
+// src/svelte/pageHandler.ts
+init_svelteServerModule();
+
+// src/core/islandPageContext.ts
+init_constants();
+var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
+var ISLAND_MARKER = 'data-island="true"';
+var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
+var ISLAND_STATE_MARKER = "__ABS_ISLAND_STATE__";
+var CLOSING_HEAD_TAG = "</head>";
+var buildIslandsHeadMarkup = (manifest) => {
+  const manifestScript = `<script>window.__ABSOLUTE_MANIFEST__ = ${JSON.stringify(manifest)}</script>`;
+  const islandStateScript = `<script>window.__ABS_ISLAND_STATE__ = ${JSON.stringify(globalThis.__ABS_ISLAND_STATE__ ?? {})}</script>`;
+  const bootstrapPath = manifest[BOOTSTRAP_MANIFEST_KEY];
+  const bootstrapScript = bootstrapPath ? `<script type="module" src="${bootstrapPath}"></script>` : "";
+  return `${manifestScript}${islandStateScript}${bootstrapScript}`;
+};
+var injectHeadMarkup = (html, markup) => {
+  const closingHeadIndex = html.indexOf("</head>");
+  if (closingHeadIndex >= 0) {
+    return `${html.slice(0, closingHeadIndex)}${markup}${html.slice(closingHeadIndex)}`;
+  }
+  const openingBodyIndex = html.indexOf("<body");
+  if (openingBodyIndex >= 0) {
+    const bodyStart = html.indexOf(">", openingBodyIndex);
+    if (bodyStart >= 0) {
+      return `${html.slice(0, openingBodyIndex)}<head>${markup}</head>${html.slice(openingBodyIndex)}`;
+    }
+  }
+  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
+};
+var streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
+var flushSafePendingText = (controller, encoder, pending, lookbehind) => {
+  if (pending.length <= lookbehind) {
+    return pending;
+  }
+  const safeText = pending.slice(0, pending.length - lookbehind);
+  controller.enqueue(encoder.encode(safeText));
+  return pending.slice(-lookbehind);
+};
+var updateInjectedState = (consumed, injected, pending) => {
+  if (consumed.done) {
+    return { done: true, injected, pending };
+  }
+  return {
+    done: false,
+    injected: consumed.injected,
+    pending: consumed.pending
+  };
+};
+var readStreamChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  if (done || !value) {
+    return { done, value: undefined };
+  }
+  return { done, value };
+};
+var pipeStreamWithHeadInjection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = CLOSING_HEAD_TAG.length - 1;
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex >= 0) {
+      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishHeadInjectionStream = (controller, pending, injected) => {
+    let finalPending = pending + decoder.decode();
+    if (!injected) {
+      finalPending = injectHeadMarkup(finalPending, markup);
+    }
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeHeadChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runHeadInjectionLoop = async (controller, reader) => {
+    const consumeNextHeadChunk = async (injected, pending) => {
+      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextHeadChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextHeadChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
+        finishHeadInjectionStream(controller, pending, injected);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const markerIndex = pending.indexOf(ISLAND_MARKER);
+    if (markerIndex >= 0) {
+      const tagStart = pending.lastIndexOf("<", markerIndex);
+      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
+      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishIslandMarkerStream = (controller, pending) => {
+    const finalPending = pending + decoder.decode();
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeIslandChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runIslandMarkerLoop = async (controller, reader) => {
+    const consumeNextIslandChunk = async (injected, pending) => {
+      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextIslandChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { pending } = await runIslandMarkerLoop(controller, reader);
+        finishIslandMarkerStream(controller, pending);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var htmlContainsIslands = (html) => html.includes(ISLAND_MARKER);
+var injectIslandPageContext = (html, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  const hasIslands = options?.hasIslands ?? htmlContainsIslands(html);
+  if (!manifest || !hasIslands) {
+    return html;
+  }
+  if (html.includes(MANIFEST_MARKER) || html.includes(ISLAND_STATE_MARKER)) {
+    return html;
+  }
+  return injectHeadMarkup(html, buildIslandsHeadMarkup(manifest));
+};
+var injectIslandPageContextStream = (stream, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  if (!manifest)
+    return stream;
+  const markup = buildIslandsHeadMarkup(manifest);
+  if (options?.hasIslands === true) {
+    return pipeStreamWithHeadInjection(stream, markup);
+  }
+  if (options?.hasIslands === false) {
+    return stream;
+  }
+  return pipeStreamWithIslandMarkerDetection(stream, markup);
+};
+var setCurrentIslandManifest = (manifest) => {
+  globalThis.__absoluteManifest = manifest;
+};
+
+// src/svelte/pageHandler.ts
+init_devRouteRegistrationCallsite();
+
+// src/core/responseEnhancers.ts
+init_streamingSlots();
+var toResponse = async (responseLike) => responseLike;
+var cloneHeaders = (response) => {
+  const headers = new Headers(response.headers);
+  return headers;
+};
+var enhanceHtmlResponseWithStreamingSlots = (response, {
+  nonce,
+  onError,
+  runtimePlacement,
+  runtimePreludeScript,
+  streamingSlots = [],
+  policy
+} = {}) => {
+  if (!response.body || streamingSlots.length === 0) {
+    return response;
+  }
+  const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
+    nonce,
+    onError,
+    policy,
+    runtimePlacement,
+    runtimePreludeScript
+  });
   return new Response(body, {
     headers: cloneHeaders(response),
     status: response.status,
     statusText: response.statusText
   });
-}, withStreamingSlots = async (responseLike, options = {}) => enhanceHtmlResponseWithStreamingSlots(await toResponse(responseLike), options), mergeStreamingSlots = (registered, explicit) => {
+};
+var withStreamingSlots = async (responseLike, options = {}) => enhanceHtmlResponseWithStreamingSlots(await toResponse(responseLike), options);
+var mergeStreamingSlots = (registered, explicit) => {
   const merged = new Map;
   for (const slot of registered)
     merged.set(slot.id, slot);
   for (const slot of explicit)
     merged.set(slot.id, slot);
   return [...merged.values()];
-}, withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
+};
+var withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
   const { result, slots } = await runWithStreamingSlotRegistry(renderResponse);
   const explicit = options.streamingSlots ?? [];
   return withStreamingSlots(result, {
@@ -1866,162 +2244,21 @@ var toResponse = async (responseLike) => responseLike, cloneHeaders = (response)
     streamingSlots: mergeStreamingSlots(slots, explicit)
   });
 };
-var init_responseEnhancers = __esm(() => {
-  init_streamingSlots();
-  init_streamingSlotRegistry();
-});
-
-// src/utils/getDurationString.ts
-var getDurationString = (duration) => {
-  let durationString;
-  if (duration < MILLISECONDS_IN_A_SECOND) {
-    durationString = `${duration.toFixed(TIME_PRECISION)}ms`;
-  } else if (duration < MILLISECONDS_IN_A_MINUTE) {
-    durationString = `${(duration / MILLISECONDS_IN_A_SECOND).toFixed(TIME_PRECISION)}s`;
-  } else {
-    durationString = `${(duration / MILLISECONDS_IN_A_MINUTE).toFixed(TIME_PRECISION)}m`;
-  }
-  return durationString;
-};
-var init_getDurationString = __esm(() => {
-  init_constants();
-});
-
-// src/utils/startupBanner.ts
-var colors, MONTHS, formatTimestamp = () => {
-  const now = new Date;
-  const month = MONTHS[now.getMonth()];
-  const day = now.getDate().toString().padStart(2, "0");
-  let hours = now.getHours();
-  const minutes = now.getMinutes().toString().padStart(2, "0");
-  const seconds = now.getSeconds().toString().padStart(2, "0");
-  const ampm = hours >= HOURS_IN_HALF_DAY ? "PM" : "AM";
-  hours = hours % HOURS_IN_HALF_DAY || HOURS_IN_HALF_DAY;
-  return `${month} ${day} ${hours}:${minutes}:${seconds} ${ampm}`;
-}, startupBanner = (options) => {
-  const {
-    version,
-    readyDuration,
-    buildDuration,
-    port,
-    host,
-    networkUrl,
-    protocol = "http"
-  } = options;
-  const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
-  const ver = `${colors.dim}v${version}${colors.reset}`;
-  const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(readyDuration)}${colors.reset}`;
-  const build = typeof buildDuration === "number" && Number.isFinite(buildDuration) ? ` ${colors.dim}(build ${getDurationString(buildDuration)})${colors.reset}` : "";
-  console.log("");
-  console.log(`  ${name} ${ver}  ${time}${build}`);
-  console.log("");
-  console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   ${protocol}://${host === "0.0.0.0" ? "localhost" : host}:${port}/`);
-  if (networkUrl) {
-    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
-  }
-  console.log("");
-};
-var init_startupBanner = __esm(() => {
-  init_constants();
-  init_getDurationString();
-  colors = {
-    bold: "\x1B[1m",
-    cyan: "\x1B[36m",
-    dim: "\x1B[2m",
-    green: "\x1B[32m",
-    reset: "\x1B[0m"
-  };
-  MONTHS = [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec"
-  ];
-});
-
-// src/utils/logger.ts
-var colors2, frameworkColors, formatPath = (filePath) => {
-  const cwd = process.cwd();
-  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative3 = relative3.replace(/\\/g, "/");
-  if (!relative3.startsWith("/")) {
-    relative3 = `/${relative3}`;
-  }
-  return relative3;
-}, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
-  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
-  const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
-  let message = action;
-  if (options?.path) {
-    const pathColor = options.framework ? getFrameworkColor(options.framework) : colors2.white;
-    message += ` ${pathColor}${formatPath(options.path)}${colors2.reset}`;
-  }
-  if (options?.duration !== undefined) {
-    message += ` ${colors2.dim}(${options.duration}ms)${colors2.reset}`;
-  }
-  console.log(`${timestamp} ${tag} ${message}`);
-}, logCssUpdate = (path, framework, duration) => {
-  log("css update", { duration, framework: framework ?? "css", path });
-}, logError = (message, error) => {
-  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
-  const tag = `${colors2.red}[hmr]${colors2.reset}`;
-  const errorMsg = error instanceof Error ? error.message : error;
-  const fullMessage = `${colors2.red}error${colors2.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
-  console.error(`${timestamp} ${tag} ${fullMessage}`);
-}, logHmrUpdate = (path, framework, duration) => {
-  log("hmr update", { duration, framework, path });
-}, logScriptUpdate = (path, framework, duration) => {
-  log("script update", { duration, framework, path });
-}, logServerReload = () => {
-  log(`${colors2.cyan}server module reloaded${colors2.reset}`);
-}, logWarn = (message) => {
-  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
-  const tag = `${colors2.yellow}[hmr]${colors2.reset}`;
-  console.log(`${timestamp} ${tag} ${colors2.yellow}warning ${message}${colors2.reset}`);
-};
-var init_logger = __esm(() => {
-  init_startupBanner();
-  colors2 = {
-    blue: "\x1B[34m",
-    bold: "\x1B[1m",
-    cyan: "\x1B[36m",
-    dim: "\x1B[2m",
-    green: "\x1B[32m",
-    magenta: "\x1B[35m",
-    red: "\x1B[31m",
-    reset: "\x1B[0m",
-    white: "\x1B[37m",
-    yellow: "\x1B[33m"
-  };
-  frameworkColors = {
-    angular: colors2.magenta,
-    assets: colors2.dim,
-    css: colors2.cyan,
-    html: colors2.white,
-    htmx: colors2.white,
-    react: colors2.blue,
-    svelte: colors2.yellow,
-    vue: colors2.green
-  };
-});
 
 // src/core/streamingSlotWarningScope.ts
+init_logger();
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var STREAMING_SLOT_WARNING_STORAGE_KEY2, isObjectRecord4 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage3 = (value) => isObjectRecord4(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", getWarningStorage = () => {
+var STREAMING_SLOT_WARNING_STORAGE_KEY2 = Symbol.for("absolutejs.streamingSlotWarningAsyncLocalStorage");
+var isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
+var isAsyncLocalStorage3 = (value) => isObjectRecord4(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getWarningStorage = () => {
   const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2);
   if (value === null || typeof value === "undefined") {
     return;
   }
   return isAsyncLocalStorage3(value) ? value : undefined;
-}, ensureWarningStorage = () => {
+};
+var ensureWarningStorage = () => {
   const existing = getWarningStorage();
   if (existing) {
     return existing;
@@ -2029,13 +2266,16 @@ var STREAMING_SLOT_WARNING_STORAGE_KEY2, isObjectRecord4 = (value) => Boolean(va
   const storage = new AsyncLocalStorage2;
   Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2, storage);
   return storage;
-}, normalizeCallsitePath2 = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, ""), formatWarningCallsite = (callsite) => {
+};
+var normalizeCallsitePath2 = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, "");
+var formatWarningCallsite = (callsite) => {
   const match = callsite.match(/^(.*?)(:\d+:\d+)$/);
   if (!match) {
     return `\x1B[36m${callsite}\x1B[0m`;
   }
   return `\x1B[36m${match[1]}\x1B[33m${match[2]}\x1B[0m`;
-}, extractCallsiteFromStack = (stack) => {
+};
+var extractCallsiteFromStack = (stack) => {
   const frames = stack.split(`
 `).slice(1).map((line) => line.trim());
   for (const frame of frames) {
@@ -2048,29 +2288,30 @@ var STREAMING_SLOT_WARNING_STORAGE_KEY2, isObjectRecord4 = (value) => Boolean(va
     }
   }
   return;
-}, buildMissingCollectorWarning = (primitiveName, handlerCallsite) => `${primitiveName} rendered during SSR without streaming slot collection enabled. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`, captureStreamingSlotWarningCallsite = () => {
+};
+var buildMissingCollectorWarning = (primitiveName, handlerCallsite) => `${primitiveName} rendered during SSR without streaming slot collection enabled. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`;
+setStreamingSlotWarningController({
+  maybeWarn: (primitiveName) => {
+    const store = getWarningStorage()?.getStore();
+    if (!store || store.hasWarned) {
+      return;
+    }
+    store.hasWarned = true;
+    logWarn(buildMissingCollectorWarning(primitiveName, store.handlerCallsite));
+  }
+});
+var captureStreamingSlotWarningCallsite = () => {
   if (false) {}
   const { stack } = new Error;
   if (!stack) {
     return;
   }
   return extractCallsiteFromStack(stack);
-}, runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
-var init_streamingSlotWarningScope = __esm(() => {
-  init_logger();
-  init_streamingSlotRegistrar();
-  STREAMING_SLOT_WARNING_STORAGE_KEY2 = Symbol.for("absolutejs.streamingSlotWarningAsyncLocalStorage");
-  setStreamingSlotWarningController({
-    maybeWarn: (primitiveName) => {
-      const store = getWarningStorage()?.getStore();
-      if (!store || store.hasWarned) {
-        return;
-      }
-      store.hasWarned = true;
-      logWarn(buildMissingCollectorWarning(primitiveName, store.handlerCallsite));
-    }
-  });
-});
+};
+var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
+
+// src/svelte/pageHandler.ts
+init_ssrCache();
 
 // src/utils/ssrErrorPage.ts
 var ssrErrorPage = (framework, error) => {
@@ -2124,39 +2365,40 @@ body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,r
 </html>`;
 };
 
-// src/utils/stringModifiers.ts
-var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
-  if (!str.includes("-") && !str.includes("_")) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
-}, toScreamingSnake = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
-
 // src/utils/resolveConvention.ts
 import { basename as basename2 } from "path";
-var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boolean(value) && typeof value === "object", getMap = () => {
+var CONVENTIONS_KEY = "__absoluteConventions";
+var isConventionsMap = (value) => Boolean(value) && typeof value === "object";
+var getMap = () => {
   const value = Reflect.get(globalThis, CONVENTIONS_KEY);
   if (isConventionsMap(value))
     return value;
   const empty = {};
   return empty;
-}, derivePageName = (pagePath) => {
+};
+var derivePageName = (pagePath) => {
   const base = basename2(pagePath);
   const dotIndex = base.indexOf(".");
   const name = dotIndex > 0 ? base.slice(0, dotIndex) : base;
   return toPascal(name);
-}, resolveErrorConventionPath = (framework, pageName) => {
+};
+var resolveErrorConventionPath = (framework, pageName) => {
   const conventions = getMap()[framework];
   if (!conventions)
     return;
   return conventions.pages?.[pageName]?.error ?? conventions.defaults?.error;
-}, resolveNotFoundConventionPath = (framework) => getMap()[framework]?.defaults?.notFound, setConventions = (map) => {
+};
+var resolveNotFoundConventionPath = (framework) => getMap()[framework]?.defaults?.notFound;
+var setConventions = (map) => {
   Reflect.set(globalThis, CONVENTIONS_KEY, map);
-}, isDev = () => true, buildErrorProps = (error) => {
+};
+var isDev = () => true;
+var buildErrorProps = (error) => {
   const message = error instanceof Error ? error.message : String(error);
   const stack = isDev() && error instanceof Error ? error.stack : undefined;
   return { error: { message, stack } };
-}, renderReactError = async (conventionPath, errorProps) => {
+};
+var renderReactError = async (conventionPath, errorProps) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
@@ -2168,7 +2410,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 500
   });
-}, renderSvelteError = async (conventionPath, errorProps) => {
+};
+var renderSvelteError = async (conventionPath, errorProps) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
@@ -2180,14 +2423,16 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 500
   });
-}, unescapeVueStyles = (ssrBody) => {
+};
+var unescapeVueStyles = (ssrBody) => {
   let styles = "";
   const body = ssrBody.replace(/<style>([\s\S]*?)<\/style>/g, (_, css) => {
     styles += `<style>${css.replace(/&quot;/g, '"').replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")}</style>`;
     return "";
   });
   return { body, styles };
-}, renderVueError = async (conventionPath, errorProps) => {
+};
+var renderVueError = async (conventionPath, errorProps) => {
   const { createSSRApp, h } = await import("vue");
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
@@ -2202,7 +2447,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 500
   });
-}, renderAngularError = async (conventionPath, errorProps) => {
+};
+var renderAngularError = async (conventionPath, errorProps) => {
   const mod = await import(conventionPath);
   const renderError = mod.default ?? mod.renderError;
   if (typeof renderError !== "function")
@@ -2212,14 +2458,22 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 500
   });
-}, logConventionRenderError = (framework, label, renderError) => {
+};
+var logConventionRenderError = (framework, label, renderError) => {
   const message = renderError instanceof Error ? renderError.message : "";
   if (message.includes("Cannot find module") || message.includes("Cannot find package") || message.includes("not found in module")) {
     console.error(`[SSR] Convention ${label} page for ${framework} failed: missing framework package. Ensure the ${framework} runtime is installed (e.g. bun add ${framework === "react" ? "react react-dom" : framework}).`);
     return;
   }
   console.error(`[SSR] Failed to render ${framework} convention ${label} page:`, renderError);
-}, ERROR_RENDERERS, renderConventionError = async (framework, pageName, error) => {
+};
+var ERROR_RENDERERS = {
+  angular: renderAngularError,
+  react: renderReactError,
+  svelte: renderSvelteError,
+  vue: renderVueError
+};
+var renderConventionError = async (framework, pageName, error) => {
   const conventionPath = resolveErrorConventionPath(framework, pageName);
   if (!conventionPath)
     return null;
@@ -2233,7 +2487,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     logConventionRenderError(framework, "error", renderError);
   }
   return null;
-}, renderReactNotFound = async (conventionPath) => {
+};
+var renderReactNotFound = async (conventionPath) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
@@ -2245,7 +2500,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 404
   });
-}, renderSvelteNotFound = async (conventionPath) => {
+};
+var renderSvelteNotFound = async (conventionPath) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
@@ -2255,7 +2511,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 404
   });
-}, renderVueNotFound = async (conventionPath) => {
+};
+var renderVueNotFound = async (conventionPath) => {
   const { createSSRApp, h } = await import("vue");
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
@@ -2270,7 +2527,8 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 404
   });
-}, renderAngularNotFound = async (conventionPath) => {
+};
+var renderAngularNotFound = async (conventionPath) => {
   const mod = await import(conventionPath);
   const renderNotFound = mod.default ?? mod.renderNotFound;
   if (typeof renderNotFound !== "function")
@@ -2280,7 +2538,14 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     headers: { "Content-Type": "text/html" },
     status: 404
   });
-}, NOT_FOUND_RENDERERS, renderConventionNotFound = async (framework) => {
+};
+var NOT_FOUND_RENDERERS = {
+  angular: renderAngularNotFound,
+  react: renderReactNotFound,
+  svelte: renderSvelteNotFound,
+  vue: renderVueNotFound
+};
+var renderConventionNotFound = async (framework) => {
   const conventionPath = resolveNotFoundConventionPath(framework);
   if (!conventionPath)
     return null;
@@ -2293,7 +2558,14 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     logConventionRenderError(framework, "not-found", renderError);
   }
   return null;
-}, NOT_FOUND_PRIORITY, renderFirstNotFound = async () => {
+};
+var NOT_FOUND_PRIORITY = [
+  "react",
+  "svelte",
+  "vue",
+  "angular"
+];
+var renderFirstNotFound = async () => {
   for (const framework of NOT_FOUND_PRIORITY) {
     if (!getMap()[framework]?.defaults?.notFound)
       continue;
@@ -2303,96 +2575,26 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
   }
   return null;
 };
-var init_resolveConvention = __esm(() => {
-  ERROR_RENDERERS = {
-    angular: renderAngularError,
-    react: renderReactError,
-    svelte: renderSvelteError,
-    vue: renderVueError
-  };
-  NOT_FOUND_RENDERERS = {
-    angular: renderAngularNotFound,
-    react: renderReactNotFound,
-    svelte: renderSvelteNotFound,
-    vue: renderVueNotFound
-  };
-  NOT_FOUND_PRIORITY = [
-    "react",
-    "svelte",
-    "vue",
-    "angular"
-  ];
-});
-
-// src/svelte/renderToReadableStream.ts
-var exports_renderToReadableStream = {};
-__export(exports_renderToReadableStream, {
-  renderToReadableStream: () => renderToReadableStream,
-  SVELTE_PAGE_ROOT_ID: () => SVELTE_PAGE_ROOT_ID
-});
-var SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__", renderToReadableStream = async (component, props, {
-  bootstrapScriptContent,
-  bootstrapScripts = [],
-  bootstrapModules = [],
-  nonce,
-  onError = console.error,
-  progressiveChunkSize = DEFAULT_CHUNK_SIZE,
-  signal,
-  headContent,
-  bodyContent
-} = {}) => {
-  try {
-    const { render } = await import("svelte/server");
-    const rendered = typeof props === "undefined" ? await render(component) : await render(component, { props });
-    const { head, body } = rendered;
-    const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
-    const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
-    const encoder = new TextEncoder;
-    const full = encoder.encode(`<!DOCTYPE html><html lang="en"><head>${head}${headContent ?? ""}</head><body><div id="${SVELTE_PAGE_ROOT_ID}">${body}</div>${scripts}${bodyContent ?? ""}</body></html>`);
-    let offset = 0;
-    return new ReadableStream({
-      type: "bytes",
-      cancel(reason) {
-        onError?.(reason);
-      },
-      pull(controller) {
-        if (signal?.aborted) {
-          controller.close();
-          return;
-        }
-        if (offset >= full.length) {
-          controller.close();
-          return;
-        }
-        const end = Math.min(offset + progressiveChunkSize, full.length);
-        controller.enqueue(full.subarray(offset, end));
-        offset = end;
-      }
-    });
-  } catch (error) {
-    onError?.(error);
-    throw error;
-  }
-};
-var init_renderToReadableStream = __esm(() => {
-  init_constants();
-  init_escapeScriptContent();
-});
 
 // src/svelte/pageHandler.ts
-var ssrDirty = false, isRecord2 = (value) => typeof value === "object" && value !== null, isGenericSvelteComponent = (value) => typeof value === "function" || isRecord2(value), readHasIslands = (value) => {
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isGenericSvelteComponent = (value) => typeof value === "function" || isRecord2(value);
+var readHasIslands = (value) => {
   if (!isRecord2(value))
     return false;
   const hasIslands = value["__ABSOLUTE_PAGE_HAS_ISLANDS__"];
   return typeof hasIslands === "boolean" ? hasIslands : false;
-}, readDefaultExport = (value) => isRecord2(value) ? value.default : undefined, buildDirtyResponse = (indexPath, props) => {
+};
+var readDefaultExport = (value) => isRecord2(value) ? value.default : undefined;
+var buildDirtyResponse = (indexPath, props) => {
   const propsScript = `window.__ABS_SLOT_HYDRATION_PENDING__=true;window.__INITIAL_PROPS__=${JSON.stringify(props)};${indexPath ? `import(${JSON.stringify(indexPath)});` : ""}`;
   const dirtyFlag = "window.__SSR_DIRTY__=true;";
   const html = `<!DOCTYPE html><html><head></head><body><script>${propsScript}${dirtyFlag}</script></body></html>`;
   return new Response(html, {
     headers: { "Content-Type": "text/html" }
   });
-}, handleSveltePageRequest = async (PageComponentOrInput, pagePath, indexPath, props, options) => {
+};
+var handleSveltePageRequest = async (PageComponentOrInput, pagePath, indexPath, props, options) => {
   const {
     PageComponent,
     indexPath: resolvedIndexPath,
@@ -2412,7 +2614,7 @@ var ssrDirty = false, isRecord2 = (value) => typeof value === "object" && value
     pagePath: pagePath ?? "",
     props
   };
-  if (ssrDirty) {
+  if (isSsrCacheDirty("svelte")) {
     return buildDirtyResponse(resolvedIndexPath, resolvedProps);
   }
   try {
@@ -2483,23 +2685,10 @@ var ssrDirty = false, isRecord2 = (value) => typeof value === "object" && value
       status: 500
     });
   }
-}, invalidateSvelteSsrCache = () => {
-  ssrDirty = true;
 };
-var init_pageHandler = __esm(() => {
-  init_svelteServerModule();
-  init_islandPageContext();
-  init_devRouteRegistrationCallsite();
-  init_responseEnhancers();
-  init_streamingSlotWarningScope();
-  init_resolveConvention();
-});
-
-// src/svelte/server.ts
-init_pageHandler();
 export {
   handleSveltePageRequest
 };
 
-//# debugId=B4B4A0E1AC4FA91264756E2164756E21
+//# debugId=30012EB2373C394964756E2164756E21
 //# sourceMappingURL=server.js.map