@absolutejs/absolute 0.19.0-beta.1041 → 0.19.0-beta.1043

package/dist/svelte/server.js

@@ -1,2996 +0,0 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __legacyMetadataTS = (k, v) => {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/build/resolvePackageImport.ts
-import { resolve, join } from "path";
-import { existsSync, readFileSync } from "fs";
-var resolveExportPath = (entry, conditions) => {
-  if (typeof entry === "string")
-    return entry;
-  if (!entry || typeof entry !== "object")
-    return null;
-  for (const condition of conditions) {
-    const target = Reflect.get(entry, condition);
-    if (typeof target === "string") {
-      return target;
-    }
-  }
-  return null;
-}, resolvePackageImport = (specifier, conditions = ["import"]) => {
-  if (specifier.startsWith(".") || specifier.startsWith("/"))
-    return null;
-  const parts = specifier.split("/");
-  const isScoped = specifier.startsWith("@");
-  const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
-  const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
-  const exportKey = subpath ? `./${subpath}` : ".";
-  const currentPackageJsonPath = resolve(process.cwd(), "package.json");
-  const currentPackageJson = existsSync(currentPackageJsonPath) ? JSON.parse(readFileSync(currentPackageJsonPath, "utf-8")) : null;
-  const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join(packageDir, "package.json");
-  if (!existsSync(packageJsonPath))
-    return null;
-  try {
-    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    const { exports } = packageJson;
-    if (!exports)
-      return null;
-    const entry = exports[exportKey];
-    if (!entry)
-      return null;
-    const importPath = resolveExportPath(entry, conditions);
-    if (!importPath)
-      return null;
-    if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
-      if (existsSync(sourceCandidate)) {
-        return sourceCandidate;
-      }
-    }
-    const resolved = resolve(packageDir, importPath);
-    return existsSync(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-};
-var init_resolvePackageImport = () => {};
-
-// src/constants.ts
-var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_CODE = 27, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, ESLINT_STUDIO_DEFAULT_HOST = "eslint.absolute.localhost", ESLINT_STUDIO_DEFAULT_PORT = 4099, CONFIG_DEFAULT_HOST = "config.absolute.localhost", CONFIG_DEFAULT_PORT = 4099, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, EXCLUDE_LAST_OFFSET = -1, HTTP_STATUS_OK = 200, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY = 75, IMAGE_GLOB_SUFFIX_LENGTH = 2, INSTANCE_PROBE_TIMEOUT_MS = 250, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, LIST_LOG_TAIL_MAX_BYTES = 65536, LIST_TUI_COLUMN_GAP = 2, LIST_TUI_DEFAULT_HEIGHT = 28, LIST_TUI_DEFAULT_WIDTH = 100, LIST_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, LIST_TUI_FOOTER_LINE_COUNT = 2, LIST_TUI_MARKER_WIDTH = 2, LIST_TUI_MIN_LOG_HEIGHT = 3, LIST_TUI_MIN_URL_WIDTH = 16, LIST_TUI_RENDER_DEBOUNCE_MS = 16, LIST_TUI_STATUS_MESSAGE_TIMEOUT_MS = 4000, LIST_WATCH_REFRESH_MS = 1000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, REACT_STREAM_SLOT_FAST_DELAY_MS = 5, REACT_STREAM_SLOT_SLOW_DELAY_MS = 20, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000, WORKSPACE_COMMAND_ARGS_OFFSET = 3, WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30, WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000, WORKSPACE_READY_PROBE_INTERVAL_MS = 250, WORKSPACE_READY_TIMEOUT_MS = 30000, WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4, WORKSPACE_TUI_DEFAULT_HEIGHT = 28, WORKSPACE_TUI_DEFAULT_WIDTH = 100, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, WORKSPACE_TUI_FOOTER_LINE_COUNT = 3, WORKSPACE_TUI_MIN_LOG_HEIGHT = 3, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7, WORKSPACE_TUI_MIN_TARGET_WIDTH = 8, WORKSPACE_TUI_MIN_WRAP_WIDTH = 12, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3, WORKSPACE_TUI_RECENT_LOG_LIMIT = 40, WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16, WORKSPACE_TUI_STATUS_WIDTH = 10, WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6, WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
-var init_constants = __esm(() => {
-  IMAGE_DEFAULT_DEVICE_SIZES = [
-    640,
-    750,
-    828,
-    1080,
-    1200,
-    1920,
-    2048,
-    3840
-  ];
-  IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
-  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
-  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
-  TWO_THIRDS = 2 / 3;
-});
-
-// src/svelte/lowerIslandSyntax.ts
-var ISLAND_TAG_RE, extractBracedExpression = (text, braceStart) => {
-  let depth = 0;
-  for (let index = braceStart;index < text.length; index += 1) {
-    const char = text[index];
-    if (char === "{")
-      depth += 1;
-    if (char === "}")
-      depth -= 1;
-    if (depth === 0) {
-      return text.slice(braceStart + 1, index).trim();
-    }
-  }
-  return null;
-}, extractIslandAttribute = (attributeString, name) => {
-  const quotedMatch = attributeString.match(new RegExp(`\\b${name}\\s*=\\s*["']([^"']+)["']`));
-  if (quotedMatch?.[1]) {
-    return { expression: JSON.stringify(quotedMatch[1]), found: true };
-  }
-  const attributeIndex = attributeString.search(new RegExp(`\\b${name}\\s*=\\s*\\{`));
-  if (attributeIndex < 0) {
-    return { expression: "", found: false };
-  }
-  const braceStart = attributeString.indexOf("{", attributeIndex);
-  if (braceStart < 0) {
-    return { expression: "", found: false };
-  }
-  const expression = extractBracedExpression(attributeString, braceStart);
-  if (expression === null) {
-    return { expression: "", found: false };
-  }
-  return { expression, found: true };
-}, lowerSvelteIslandSyntax = (source, _mode = "server") => {
-  if (!source.includes("<Island")) {
-    return { code: source, transformed: false };
-  }
-  let islandIndex = 0;
-  const transformedMarkup = source.replace(ISLAND_TAG_RE, (fullMatch, attributeString) => {
-    const framework = extractIslandAttribute(attributeString, "framework");
-    const component = extractIslandAttribute(attributeString, "component");
-    if (!framework.found || !component.found) {
-      return fullMatch;
-    }
-    const hydrate = extractIslandAttribute(attributeString, "hydrate");
-    const props = extractIslandAttribute(attributeString, "props");
-    const slotId = `absolute-svelte-island-${islandIndex.toString(BASE_36_RADIX)}`;
-    islandIndex += 1;
-    const resolveExpression = `await __absoluteResolveIslandHtml(${JSON.stringify(slotId)}, { component: ${component.expression}, framework: ${framework.expression}, hydrate: ${hydrate.found ? hydrate.expression : JSON.stringify("load")}, props: ${props.found ? props.expression : "{}"} })`;
-    return `<div data-absolute-island-slot="${slotId}" style="display: contents">{@html ${resolveExpression}}</div>`;
-  });
-  const importLine = 'import { resolveIslandHtml as __absoluteResolveIslandHtml } from "@absolutejs/absolute/svelte";';
-  if (transformedMarkup.includes("<script")) {
-    return {
-      code: transformedMarkup.replace(/<script(\s[^>]*)?>/, (match) => `${match}
-${importLine}
-`),
-      transformed: true
-    };
-  }
-  return {
-    code: `<script lang="ts">
-${importLine}
-</script>
-${transformedMarkup}`,
-    transformed: true
-  };
-};
-var init_lowerIslandSyntax = __esm(() => {
-  init_constants();
-  ISLAND_TAG_RE = /<Island\b([\s\S]*?)\/>/g;
-});
-
-// src/svelte/lowerAwaitSlotSyntax.ts
-var AWAIT_BLOCK_RE, escapeTemplateLiteral = (value) => value.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${"), markupToTemplateLiteral = (markup) => {
-  const escaped = escapeTemplateLiteral(markup.trim());
-  const withExpressions = escaped.replace(/\{([^{}]+)\}/g, (_, expression) => `\${${String(expression).trim()}}`);
-  return `\`${withExpressions}\``;
-}, lowerSvelteAwaitSlotSyntax = (source) => {
-  if (!source.includes("{#await")) {
-    return { code: source, transformed: false };
-  }
-  let awaitIndex = 0;
-  let transformed = false;
-  const lowered = source.replace(AWAIT_BLOCK_RE, (fullMatch, awaitExpression, pendingMarkup, thenIdentifier, thenMarkup, catchIdentifier, catchMarkup) => {
-    const trimmedAwaitExpression = awaitExpression.trim();
-    if (!trimmedAwaitExpression) {
-      return fullMatch;
-    }
-    const slotId = `absolute-svelte-await-${awaitIndex.toString(BASE_36_RADIX)}`;
-    awaitIndex += 1;
-    transformed = true;
-    const thenValueIdentifier = thenIdentifier?.trim() || "__awaitValue";
-    const catchValueIdentifier = catchIdentifier?.trim() || "__awaitError";
-    const fallbackHtml = markupToTemplateLiteral(pendingMarkup);
-    const resolvedHtml = markupToTemplateLiteral(thenMarkup);
-    const rejectedHtml = typeof catchMarkup === "string" ? markupToTemplateLiteral(catchMarkup) : null;
-    const catchBranch = rejectedHtml ? `catch (${catchValueIdentifier}) { return ${rejectedHtml}; }` : "catch (_absoluteAwaitError) { throw _absoluteAwaitError; }";
-    return `<AbsoluteAwaitSlot id="${slotId}" fallbackHtml={${fallbackHtml}} resolve={async () => { try { const ${thenValueIdentifier} = await (${trimmedAwaitExpression}); return ${resolvedHtml}; } ${catchBranch} }} />`;
-  });
-  if (!transformed) {
-    return { code: source, transformed: false };
-  }
-  const importLine = 'import AbsoluteAwaitSlot from "@absolutejs/absolute/svelte/components/AwaitSlot.svelte";';
-  if (lowered.includes("<script")) {
-    return {
-      code: lowered.replace(/<script(\s[^>]*)?>/, (match) => `${match}
-${importLine}
-`),
-      transformed: true
-    };
-  }
-  return {
-    code: `<script lang="ts">
-${importLine}
-</script>
-${lowered}`,
-    transformed: true
-  };
-};
-var init_lowerAwaitSlotSyntax = __esm(() => {
-  init_constants();
-  AWAIT_BLOCK_RE = /\{#await\s+([^}]+)\}([\s\S]*?)\{:then(?:\s+([A-Za-z_$][\w$]*))?\}([\s\S]*?)(?:\{:catch(?:\s+([A-Za-z_$][\w$]*))?\}([\s\S]*?))?\{\/await\}/g;
-});
-
-// src/build/stylePreprocessor.ts
-var exports_stylePreprocessor = {};
-__export(exports_stylePreprocessor, {
-  stylePreprocessorPlugin: () => stylePreprocessorPlugin,
-  recordStyleOutput: () => recordStyleOutput,
-  isStylePath: () => isStylePath,
-  isStyleModulePath: () => isStyleModulePath,
-  isPreprocessableStylePath: () => isPreprocessableStylePath,
-  getStyleBaseName: () => getStyleBaseName,
-  getCssOutputExtension: () => getCssOutputExtension,
-  forgetStyleEntry: () => forgetStyleEntry,
-  findStyleEntriesImporting: () => findStyleEntriesImporting,
-  createSvelteStylePreprocessor: () => createSvelteStylePreprocessor,
-  createStyleTransformConfig: () => createStyleTransformConfig,
-  createStylePreprocessorPlugin: () => createStylePreprocessorPlugin,
-  compileStyleSource: () => compileStyleSource,
-  compileStyleFileIfNeededSync: () => compileStyleFileIfNeededSync,
-  compileStyleFileIfNeeded: () => compileStyleFileIfNeeded,
-  addStyleImporter: () => addStyleImporter
-});
-import { createHash } from "crypto";
-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, pathToFileURL } from "url";
-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";
-  if (normalized === "sass" || normalized.endsWith(".sass"))
-    return "sass";
-  if (normalized === "less" || normalized.endsWith(".less"))
-    return "less";
-  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.`), throwPreprocessorError = (error, filePath, language) => {
-  if (!(error instanceof Error)) {
-    throw new Error(`${language} compile failed in ${filePath}: ${String(error)}`);
-  }
-  const detail = error;
-  const sassLine = detail.span?.start?.line;
-  const sassCol = detail.span?.start?.column;
-  const line = detail.line ?? sassLine;
-  const column = detail.column ?? sassCol;
-  const location = typeof line === "number" ? `:${line}${typeof column === "number" ? `:${column}` : ""}` : "";
-  const message = detail.formatted ?? detail.message;
-  const wrapped = new Error(`${language} compile failed in ${filePath}${location}
-${message}`);
-  wrapped.cause = error;
-  throw wrapped;
-}, requireOptionalPeerSync = (specifier) => {
-  try {
-    return requireFromCwd(specifier);
-  } catch {
-    return requireOptionalPeer(specifier);
-  }
-}, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname(filePath),
-  process.cwd(),
-  ...paths.map((path) => resolve2(process.cwd(), path))
-], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
-  pattern,
-  replacements: Array.isArray(value) ? value : [value]
-})), readTsconfigAliases = () => {
-  const cwd = process.cwd();
-  if (tsconfigAliasCache?.cwd === cwd)
-    return tsconfigAliasCache;
-  const tsconfigPath = resolve2(cwd, "tsconfig.json");
-  const empty = { aliases: [], baseUrl: cwd, cwd };
-  if (!existsSync2(tsconfigPath)) {
-    tsconfigAliasCache = empty;
-    return empty;
-  }
-  try {
-    const parsed = JSON.parse(stripJsonComments(readFileSync2(tsconfigPath, "utf-8")));
-    const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve2(cwd, compilerOptions.baseUrl ?? ".");
-    tsconfigAliasCache = {
-      aliases: normalizeAliasEntries(compilerOptions.paths),
-      baseUrl,
-      cwd
-    };
-  } catch {
-    tsconfigAliasCache = empty;
-  }
-  return tsconfigAliasCache;
-}, getAliasEntries = (config) => {
-  const tsconfig = readTsconfigAliases();
-  return {
-    aliases: [
-      ...normalizeAliasEntries(config?.aliases),
-      ...tsconfig.aliases
-    ],
-    baseUrl: tsconfig.baseUrl
-  };
-}, aliasPatternToRegExp = (pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("(.+)")}$`), resolveAliasTargets = (specifier, config) => {
-  const { aliases, baseUrl } = getAliasEntries(config);
-  const targets = [];
-  for (const alias of aliases) {
-    const match = specifier.match(aliasPatternToRegExp(alias.pattern));
-    if (!match)
-      continue;
-    const wildcard = match[1] ?? "";
-    for (const replacement of alias.replacements) {
-      targets.push(resolve2(baseUrl, replacement.replace("*", wildcard)));
-    }
-  }
-  return targets;
-}, getLanguageExtensions = (language) => {
-  if (language === "less")
-    return [".less", ".css"];
-  if (language === "stylus")
-    return [".styl", ".stylus", ".css"];
-  return [".scss", ".sass", ".css"];
-}, getCandidatePaths = (basePath, language) => {
-  const ext = extname(basePath);
-  const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
-    `${basePath}${extension}`,
-    join2(basePath, `index${extension}`)
-  ]);
-  if (language === "scss" || language === "sass") {
-    return paths.flatMap((path) => {
-      const dir = dirname(path);
-      const base = path.slice(dir.length + 1);
-      return [path, join2(dir, `_${base}`)];
-    });
-  }
-  return paths;
-}, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
-  const rawCandidates = [
-    ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve2(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve2(path, specifier))
-  ];
-  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
-    if (existsSync2(candidate))
-      return candidate;
-  }
-  return null;
-}, isExternalCssUrl = (url) => /^(?:[a-z][a-z0-9+.-]*:|\/\/|#|\/)/i.test(url), splitCssUrl = (url) => {
-  const markerIndex = url.search(/[?#]/);
-  if (markerIndex === -1)
-    return { marker: "", path: url };
-  return {
-    marker: url.slice(markerIndex),
-    path: url.slice(0, markerIndex)
-  };
-}, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname(sourceFile);
-  const entryDir = dirname(entryFile);
-  if (sourceDir === entryDir)
-    return contents;
-  return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
-    const trimmedUrl = rawUrl.trim();
-    if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
-      return match;
-    const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve2(sourceDir, path)).replace(/\\/g, "/");
-    const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
-    const nextQuote = quote || '"';
-    return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
-  });
-}, rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
-  if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
-    return match;
-  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
-  return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
-}), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
-  const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
-  return language ? rewriteAliasedStyleImports(rebased, sourceFile, loadPaths, language, config) : rebased;
-}, extractCssModuleExports = (css) => {
-  const exports = {};
-  const nextCss = css.replace(/:export\s*\{([^}]*)\}/g, (_, body) => {
-    for (const declaration of body.split(";")) {
-      const separator = declaration.indexOf(":");
-      if (separator === -1)
-        continue;
-      const key = declaration.slice(0, separator).trim();
-      const value = declaration.slice(separator + 1).trim();
-      if (key && value)
-        exports[key] = value;
-    }
-    return "";
-  });
-  return { css: nextCss, exports };
-}, getSassOptions = (config, language) => ({
-  ...config?.sass ?? {},
-  ...language === "scss" ? config?.scss ?? {} : {}
-}), 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, deps) => ({
-  canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
-    const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL(resolve2(resolved)).href) : null;
-  },
-  load(canonicalUrl) {
-    const filePath = fileURLToPath(canonicalUrl);
-    deps?.add(filePath);
-    const fileLanguage = getStyleLanguage(filePath);
-    if (fileLanguage !== "scss" && fileLanguage !== "sass" && fileLanguage !== null)
-      return null;
-    return {
-      contents: preprocessLoadedStyle(readFileSync2(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
-      syntax: filePath.endsWith(".sass") ? "indented" : "scss"
-    };
-  }
-}), createLessFileManager = (entryFile, loadPaths, config, deps) => ({
-  install(less, pluginManager) {
-    const baseManager = new less.FileManager;
-    const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve2(currentDirectory), loadPaths, "less", config));
-    manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve2(currentDirectory), loadPaths, "less", config);
-      if (!resolved) {
-        throw new Error(`Unable to resolve Less import "${filename}"`);
-      }
-      deps?.add(resolved);
-      return {
-        contents: preprocessLoadedStyle(await readFile(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
-        filename: resolved
-      };
-    };
-    pluginManager.addFileManager(manager);
-  }
-}), renderStylus = async (contents, filePath, loadPaths, options, deps) => {
-  let stylus;
-  try {
-    const stylusModule = await importOptionalPeer("stylus");
-    stylus = stylusModule.default ?? stylusModule;
-  } catch {
-    throw missingDependencyError("stylus", filePath);
-  }
-  return new Promise((resolveCss, reject) => {
-    const renderer = stylus(contents);
-    renderer.set("filename", filePath);
-    for (const [key, value] of Object.entries(options.options ?? {})) {
-      renderer.set(key, value);
-    }
-    for (const path of loadPaths)
-      renderer.include(path);
-    renderer.render((error, css) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      if (deps) {
-        const stylusDeps = renderer.deps?.();
-        if (Array.isArray(stylusDeps)) {
-          for (const dep of stylusDeps)
-            deps.add(resolve2(dep));
-        }
-      }
-      resolveCss(css ?? "");
-    });
-  });
-}, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve2(entry);
-  const stripped = new Set;
-  for (const dep of deps) {
-    const resolved = resolve2(dep);
-    if (resolved !== key)
-      stripped.add(resolved);
-  }
-  styleDependencyGraph.set(key, stripped);
-}, addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve2(importerPath);
-  const target = resolve2(stylePath);
-  const deps = styleDependencyGraph.get(key) ?? new Set;
-  deps.add(target);
-  styleDependencyGraph.set(key, deps);
-}, findStyleEntriesImporting = (changedPath) => {
-  const target = resolve2(changedPath);
-  const importers = [];
-  for (const [entry, deps] of styleDependencyGraph) {
-    if (deps.has(target))
-      importers.push(entry);
-  }
-  return importers;
-}, recordStyleOutput = (entry, css) => {
-  const key = resolve2(entry);
-  const hash = createHash("sha1").update(css).digest("hex");
-  const previous = styleOutputHashes.get(key);
-  styleOutputHashes.set(key, hash);
-  return previous !== hash;
-}, forgetStyleEntry = (entry) => {
-  const key = resolve2(entry);
-  styleDependencyGraph.delete(key);
-  styleOutputHashes.delete(key);
-}, compileStyleSource = async (filePath, source, languageHint, config) => {
-  const language = getStyleLanguage(languageHint ?? filePath);
-  const rawContents = source ?? await readFile(filePath, "utf-8");
-  const deps = new Set;
-  if (language === "scss" || language === "sass") {
-    const options = getSassOptions(config, language);
-    const packageName = options.implementation ?? "sass";
-    let sass;
-    try {
-      sass = await importOptionalPeer(packageName);
-    } catch {
-      throw missingDependencyError(packageName, filePath);
-    }
-    const contents = withAdditionalData(rawContents, options.additionalData);
-    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
-    try {
-      const result = sass.compileString(contents, {
-        importers: [
-          createSassImporter(filePath, loadPaths, language, config, deps)
-        ],
-        loadPaths,
-        style: "expanded",
-        syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL(resolve2(filePath)).href)
-      });
-      const css = await runPostcss(result.css, filePath, config);
-      const loadedUrls = result.loadedUrls ?? [];
-      for (const url of loadedUrls) {
-        if (url.protocol !== "file:")
-          continue;
-        const dep = fileURLToPath(url);
-        if (resolve2(dep) === resolve2(filePath))
-          continue;
-        deps.add(dep);
-      }
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, language);
-    }
-  }
-  if (language === "less") {
-    const options = getLessOptions(config);
-    let lessModule;
-    try {
-      lessModule = await importOptionalPeer("less");
-    } catch {
-      throw missingDependencyError("less", filePath);
-    }
-    const less = lessModule.render ? lessModule : lessModule.default;
-    const render = less?.render;
-    if (!render)
-      throw missingDependencyError("less", filePath);
-    const contents = withAdditionalData(rawContents, options.additionalData);
-    const loadPaths = normalizeLoadPaths(filePath, options.paths);
-    try {
-      const result = await render(contents, {
-        ...options.options ?? {},
-        filename: filePath,
-        paths: loadPaths,
-        plugins: [
-          ...options.options?.plugins ?? [],
-          createLessFileManager(filePath, loadPaths, config, deps)
-        ]
-      });
-      const css = await runPostcss(result.css, filePath, config);
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, "less");
-    }
-  }
-  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);
-    try {
-      const css = await runPostcss(await renderStylus(contents, filePath, loadPaths, options, deps), filePath, config);
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, "stylus");
-    }
-  }
-  return runPostcss(rawContents, filePath, config);
-}, createStylePreprocessorPlugin = (config) => ({
-  name: "absolute-style-preprocessor",
-  setup(build) {
-    const cssModuleSources = new Map;
-    build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
-      namespace: "absolute-style-module",
-      path: path.slice("absolute-style-module:".length)
-    }));
-    build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
-      const source = cssModuleSources.get(path);
-      if (!source) {
-        throw new Error(`Unable to resolve CSS module source for ${path}`);
-      }
-      return {
-        contents: source.css,
-        loader: "css"
-      };
-    });
-    build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
-      if (isStyleModulePath(path)) {
-        const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
-        const compiled = await compileStyleSource(path, undefined, undefined, config);
-        const { css, exports } = extractCssModuleExports(compiled);
-        cssModuleSources.set(cssModulePath, { css, exports });
-        const exportSource = Object.keys(exports).length > 0 ? `import styles from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)}; export default Object.assign({}, styles, ${JSON.stringify(exports)});` : `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`;
-        return {
-          contents: exportSource,
-          loader: "js"
-        };
-      }
-      return {
-        contents: await compileStyleSource(path, undefined, undefined, config),
-        loader: "css"
-      };
-    });
-    build.onLoad({ filter: CSS_EXTENSION_PATTERN }, async ({ path }) => ({
-      contents: await compileStyleSource(path, undefined, undefined, config),
-      loader: "css"
-    }));
-  }
-}), stylePreprocessorPlugin, createSvelteStylePreprocessor = (config) => ({
-  style: async ({
-    attributes,
-    content,
-    filename
-  }) => {
-    const language = typeof attributes.lang === "string" ? attributes.lang : typeof attributes.type === "string" ? attributes.type.replace(/^text\//, "") : null;
-    if (!language || !STYLE_LANGUAGE_PATTERN.test(language))
-      return;
-    const path = filename ?? `style.${language}`;
-    return {
-      code: await compileStyleSource(path, content, language, config)
-    };
-  }
-}), CSS_IMPORT_PATTERN, resolveCssImportsAsync = async (content, baseDir, visited) => {
-  const matches = Array.from(content.matchAll(CSS_IMPORT_PATTERN));
-  if (matches.length === 0)
-    return content;
-  let cursor = 0;
-  const parts = [];
-  for (const match of matches) {
-    const importPath = match[1];
-    if (importPath === undefined)
-      continue;
-    const start = match.index ?? 0;
-    const end = start + match[0].length;
-    parts.push(content.slice(cursor, start));
-    const fullPath = isAbsolute(importPath) ? importPath : resolve2(baseDir, importPath);
-    if (visited.has(fullPath) || !existsSync2(fullPath)) {
-      parts.push(visited.has(fullPath) ? "" : match[0]);
-      cursor = end;
-      continue;
-    }
-    const nextVisited = new Set(visited);
-    nextVisited.add(fullPath);
-    const imported = await readFile(fullPath, "utf-8");
-    parts.push(await resolveCssImportsAsync(imported, dirname(fullPath), nextVisited));
-    cursor = end;
-  }
-  parts.push(content.slice(cursor));
-  return parts.join("");
-}, compileStyleFileIfNeeded = async (filePath, config) => {
-  if (!isPreprocessableStylePath(filePath)) {
-    const raw = await readFile(filePath, "utf-8");
-    const processed = await runPostcss(raw, filePath, config);
-    return resolveCssImportsAsync(processed, dirname(filePath), new Set([filePath]));
-  }
-  const compiled = await compileStyleSource(filePath, undefined, undefined, config);
-  return resolveCssImportsAsync(compiled, dirname(filePath), new Set([filePath]));
-}, resolveCssImportsSync = (content, baseDir, visited) => {
-  return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
-    const fullPath = isAbsolute(importPath) ? importPath : resolve2(baseDir, importPath);
-    if (visited.has(fullPath))
-      return "";
-    if (!existsSync2(fullPath))
-      return match;
-    const nextVisited = new Set(visited);
-    nextVisited.add(fullPath);
-    const imported = readFileSync2(fullPath, "utf-8");
-    return resolveCssImportsSync(imported, dirname(fullPath), nextVisited);
-  });
-}, 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);
-    const result = sass.compileString(contents, {
-      importers: [
-        createSassImporter(filePath, loadPaths, language, config)
-      ],
-      loadPaths,
-      style: "expanded",
-      syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(pathToFileURL(resolve2(filePath)).href)
-    });
-    const loadedUrls = result.loadedUrls ?? [];
-    for (const url of loadedUrls) {
-      if (url.protocol !== "file:")
-        continue;
-      const dep = fileURLToPath(url);
-      if (resolve2(dep) === resolve2(filePath))
-        continue;
-      addStyleImporter(filePath, dep);
-    }
-    return resolveCssImportsSync(result.css, dirname(filePath), new Set([filePath]));
-  }
-  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 resolveCssImportsSync(rawContents, dirname(filePath), new Set([filePath]));
-}, 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;
-  importOptionalPeer = new Function("specifier", "return import(specifier)");
-  requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join2(process.cwd(), "package.json"));
-  styleDependencyGraph = new Map;
-  styleOutputHashes = new Map;
-  stylePreprocessorPlugin = createStylePreprocessorPlugin();
-  CSS_IMPORT_PATTERN = /@import\s+["']([^"']+)["']\s*;?/g;
-});
-
-// src/core/svelteServerModule.ts
-import { mkdir, readdir } from "fs/promises";
-import { basename, dirname as dirname2, extname as extname2, join as join3, relative as relative2, resolve as resolve3 } from "path";
-var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname2(from), target).replace(/\\/g, "/");
-  return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
-  for (const entry of entries) {
-    const entryPath = join3(dir, entry.name);
-    if (entry.isDirectory())
-      stack.push(entryPath);
-    if (entry.isFile() && entry.name === targetFileName) {
-      return entryPath;
-    }
-  }
-  return null;
-}, searchDirectoryLevel = async (dirs, targetFileName) => {
-  if (dirs.length === 0)
-    return null;
-  const nextStack = [];
-  const dirEntries = await Promise.all(dirs.map(async (dir) => ({
-    dir,
-    entries: await readdir(dir, {
-      encoding: "utf-8",
-      withFileTypes: true
-    })
-  })));
-  for (const { dir, entries } of dirEntries) {
-    const found = processDirectoryEntries(entries, dir, targetFileName, nextStack);
-    if (found)
-      return found;
-  }
-  return searchDirectoryLevel(nextStack, targetFileName);
-}, findSourceFileByBasename = async (searchRoot, targetFileName) => searchDirectoryLevel([searchRoot], targetFileName), normalizeBuiltSvelteFileName = (sourcePath) => basename(sourcePath).replace(/-[a-z0-9]{6,}(?=\.svelte$)/i, ""), resolveOriginalSourcePath = async (sourcePath) => {
-  const cachedPath = originalSourcePathCache.get(sourcePath);
-  if (cachedPath !== undefined) {
-    return cachedPath;
-  }
-  if (!sourcePath.includes(`${join3(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
-    originalSourcePathCache.set(sourcePath, sourcePath);
-    return sourcePath;
-  }
-  const resolvedSourcePath = await findSourceFileByBasename(join3(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
-  const nextPath = resolvedSourcePath ?? sourcePath;
-  originalSourcePathCache.set(sourcePath, nextPath);
-  return nextPath;
-}, resolveRelativeModule = async (spec, from) => {
-  if (!spec.startsWith(".")) {
-    return null;
-  }
-  const basePath = resolve3(dirname2(from), spec);
-  const candidates = [
-    basePath,
-    `${basePath}.ts`,
-    `${basePath}.js`,
-    `${basePath}.mjs`,
-    `${basePath}.cjs`,
-    `${basePath}.json`,
-    join3(basePath, "index.ts"),
-    join3(basePath, "index.js"),
-    join3(basePath, "index.mjs"),
-    join3(basePath, "index.cjs"),
-    join3(basePath, "index.json")
-  ];
-  const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
-  const foundIndex = existResults.indexOf(true);
-  return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
-}, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
-  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join3(serverCacheRoot, `${normalizedSourcePath}.server.js`);
-}, resolveSvelteImport = async (spec, from) => {
-  if (!spec.startsWith(".") && !spec.startsWith("/")) {
-    const resolved = resolvePackageImport(spec);
-    return resolved && resolved.endsWith(".svelte") ? resolved : null;
-  }
-  if (spec.startsWith("/")) {
-    return spec;
-  }
-  if (!spec.startsWith(".")) {
-    return null;
-  }
-  const explicitPath = resolve3(dirname2(from), spec);
-  if (extname2(explicitPath) === ".svelte") {
-    return explicitPath;
-  }
-  const candidate = `${explicitPath}.svelte`;
-  if (await Bun.file(candidate).exists() === true) {
-    return candidate;
-  }
-  return null;
-}, writeIfChanged = async (path, content) => {
-  const targetFile = Bun.file(path);
-  const exists = await targetFile.exists();
-  if (exists) {
-    const currentContent = await targetFile.text();
-    if (currentContent === content) {
-      return;
-    }
-  }
-  await Bun.write(path, content);
-}, compileSvelteServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache.get(sourcePath);
-  if (cachedModulePath) {
-    return cachedModulePath;
-  }
-  const resolutionSourcePath = await resolveOriginalSourcePath(sourcePath);
-  const source = await Bun.file(sourcePath).text();
-  const { compile, preprocess } = await import("svelte/compiler");
-  const loweredAwaitSource = lowerSvelteAwaitSlotSyntax(source);
-  const loweredSource = lowerSvelteIslandSyntax(loweredAwaitSource.code, "server");
-  const preprocessed = await preprocess(loweredSource.code, createSvelteStylePreprocessor());
-  let transpiled = sourcePath.endsWith(".ts") || sourcePath.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed.code) : preprocessed.code;
-  const childImportSpecs = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((value) => value !== undefined);
-  const resolvedChildModules = await Promise.all(childImportSpecs.map((spec) => resolveSvelteImport(spec, resolutionSourcePath)));
-  const resolvedModuleImports = await Promise.all(childImportSpecs.map((spec) => resolveRelativeModule(spec, resolutionSourcePath)));
-  const childModulePaths = new Map;
-  const rewrittenModulePaths = new Map;
-  const compiledChildren = await Promise.all(childImportSpecs.map(async (spec, index) => {
-    const resolvedChild = resolvedChildModules[index];
-    if (!spec || !resolvedChild)
-      return null;
-    return {
-      compiledPath: await compileSvelteServerModule(resolvedChild),
-      resolvedChild,
-      spec
-    };
-  }));
-  for (const result of compiledChildren) {
-    if (!result)
-      continue;
-    childModulePaths.set(result.spec, result.compiledPath);
-    childModulePaths.set(result.resolvedChild, result.compiledPath);
-  }
-  for (let index = 0;index < childImportSpecs.length; index += 1) {
-    const spec = childImportSpecs[index];
-    const resolvedModuleImport = resolvedModuleImports[index];
-    if (!spec || !resolvedModuleImport)
-      continue;
-    if (resolvedChildModules[index])
-      continue;
-    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), resolvedModuleImport));
-  }
-  for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
-    transpiled = transpiled.replaceAll(spec, resolvedModuleImport);
-  }
-  let compiledCode = compile(transpiled, {
-    css: "injected",
-    experimental: {
-      async: loweredAwaitSource.transformed || loweredSource.transformed
-    },
-    filename: resolutionSourcePath,
-    generate: "server"
-  }).js.code;
-  for (const [spec, compiledChildPath] of childModulePaths) {
-    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), compiledChildPath));
-  }
-  for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
-    compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
-  }
-  const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir(dirname2(compiledModulePath), { recursive: true });
-  await writeIfChanged(compiledModulePath, compiledCode);
-  compiledModuleCache.set(sourcePath, compiledModulePath);
-  return compiledModulePath;
-};
-var init_svelteServerModule = __esm(() => {
-  init_resolvePackageImport();
-  init_lowerIslandSyntax();
-  init_lowerAwaitSlotSyntax();
-  init_stylePreprocessor();
-  serverCacheRoot = join3(process.cwd(), ".absolutejs", "islands", "svelte");
-  compiledModuleCache = new Map;
-  originalSourcePathCache = new Map;
-  transpiler = new Bun.Transpiler({
-    loader: "ts",
-    target: "browser"
-  });
-});
-
-// src/core/devRouteRegistrationCallsite.ts
-var exports_devRouteRegistrationCallsite = {};
-__export(exports_devRouteRegistrationCallsite, {
-  patchElysiaRouteRegistrationCallsites: () => patchElysiaRouteRegistrationCallsites,
-  isPageHandler: () => isPageHandler,
-  getOriginalPageHandlerSource: () => getOriginalPageHandlerSource,
-  getCurrentRouteRegistrationCallsite: () => getCurrentRouteRegistrationCallsite
-});
-import { AsyncLocalStorage } from "async_hooks";
-import { Elysia } from "elysia";
-var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, PAGE_HANDLER_NAMES, pageHandlerWrappers, handlerSourceMentionsPageHelper = (handler) => {
-  const source = handler.toString();
-  return PAGE_HANDLER_NAMES.some((name) => source.includes(name));
-}, getOriginalPageHandlerSource = (handler) => {
-  if (typeof handler !== "function")
-    return;
-  const fn = handler;
-  const info = pageHandlerWrappers.get(fn);
-  return (info?.originalHandler ?? fn).toString();
-}, isPageHandler = (handler) => {
-  if (typeof handler !== "function")
-    return false;
-  const fn = handler;
-  if (pageHandlerWrappers.has(fn))
-    return true;
-  return handlerSourceMentionsPageHelper(fn);
-}, 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", isRouteMethod = (value) => typeof value === "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(/^\.\/+/, ""), shouldIgnoreRouteCallsiteFrame = (frame) => frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/core/devRouteRegistrationCallsite."), getRouteCallsiteLocation = (frame) => frame.match(/\((\/[^)]+:\d+:\d+)\)$/)?.[1] ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/)?.[1], extractRouteRegistrationCallsite = (stack) => {
-  const location = stack.split(`
-`).slice(1).map((line) => line.trim()).filter((frame) => !shouldIgnoreRouteCallsiteFrame(frame)).map((frame) => getRouteCallsiteLocation(frame)).find((frameLocation) => frameLocation !== undefined);
-  return location ? normalizeCallsitePath(location) : undefined;
-}, captureRouteRegistrationCallsite = () => {
-  const { stack } = new Error;
-  if (!stack) {
-    return;
-  }
-  return extractRouteRegistrationCallsite(stack);
-}, wrapRouteHandlerWithCallsite = (handler, callsite) => {
-  if (typeof handler !== "function" || !callsite) {
-    return handler;
-  }
-  const storage = ensureRouteCallsiteStorage();
-  const routeHandler = handler;
-  return function wrappedRouteHandler(...args) {
-    return storage.run({ callsite }, () => Reflect.apply(routeHandler, this, args));
-  };
-}, createPatchedRouteMethod = (originalMethod, methodName) => function patchedRouteMethod(path, handler, ...rest) {
-  const callsite = captureRouteRegistrationCallsite();
-  const wrapped = wrapRouteHandlerWithCallsite(handler, callsite);
-  if (methodName === "get" && typeof handler === "function" && typeof wrapped === "function" && handlerSourceMentionsPageHelper(handler)) {
-    pageHandlerWrappers.set(wrapped, {
-      originalHandler: handler
-    });
-  }
-  return Reflect.apply(originalMethod, this, [path, wrapped, ...rest]);
-}, getCurrentRouteRegistrationCallsite = () => getRouteCallsiteStorage()?.getStore()?.callsite, patchElysiaRouteRegistrationCallsites = () => {
-  if (false) {}
-  if (Reflect.get(globalThis, ROUTE_CALLSITE_PATCHED_KEY) === true) {
-    return;
-  }
-  const { prototype } = Elysia;
-  ROUTE_METHOD_NAMES.forEach((methodName) => {
-    const originalMethod = Reflect.get(prototype, methodName);
-    if (!isRouteMethod(originalMethod))
-      return;
-    Reflect.set(prototype, methodName, createPatchedRouteMethod(originalMethod, methodName));
-  });
-  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"
-  ];
-  PAGE_HANDLER_NAMES = [
-    "handleReactPageRequest",
-    "handleSveltePageRequest",
-    "handleVuePageRequest",
-    "handleAngularPageRequest",
-    "handleHTMLPageRequest",
-    "handleHTMXPageRequest"
-  ];
-  pageHandlerWrappers = new WeakMap;
-});
-
-// src/client/streamSwap.ts
-var streamSwapRuntime = () => {
-  const absoluteWindow = window;
-  const SLOT_PATCH_EVENT = "absolutejs:slot-patch";
-  if (absoluteWindow.__ABS_SLOT_RUNTIME__ === true)
-    return;
-  absoluteWindow.__ABS_SLOT_RUNTIME__ = true;
-  absoluteWindow.__ABS_SLOT_CONSUMERS__ = absoluteWindow.__ABS_SLOT_CONSUMERS__ ?? {};
-  absoluteWindow.__ABS_SLOT_PENDING__ = absoluteWindow.__ABS_SLOT_PENDING__ ?? {};
-  const consumers = absoluteWindow.__ABS_SLOT_CONSUMERS__;
-  const pending = absoluteWindow.__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 = () => absoluteWindow.__ABS_SLOT_HYDRATION_PENDING__ !== true;
-  const isAngularDeferPayload = (payload) => {
-    if (!isObjectRecord4(payload))
-      return false;
-    return payload.kind === "angular-defer";
-  };
-  const isVueSuspensePayload = (payload) => {
-    if (!isObjectRecord4(payload))
-      return false;
-    return payload.kind === "vue-suspense";
-  };
-  const resolveHtml = (payload) => {
-    if (!isObjectRecord4(payload)) {
-      return typeof payload === "string" ? payload : "";
-    }
-    if (typeof payload.html === "string") {
-      return payload.html;
-    }
-    return "";
-  };
-  const apply = (id, pendingEntry) => {
-    const payload = unwrapPendingPayload(pendingEntry);
-    if (!canApplyImmediately()) {
-      pending[id] = payload;
-      return;
-    }
-    const consumer = consumers[id];
-    if (typeof consumer !== "function") {
-      applyToDom(id, payload, pendingEntry);
-      return;
-    }
-    const handled = consumer(payload);
-    if (handled !== false) {
-      delete pending[id];
-      return;
-    }
-    applyToDom(id, payload, pendingEntry);
-  };
-  const applyToDom = (id, payload, pendingEntry) => {
-    if (isAngularDeferPayload(payload)) {
-      pending[id] = payload;
-      return;
-    }
-    const node = document.getElementById(id);
-    if (!node) {
-      pending[id] = payload;
-      return;
-    }
-    const html = resolveHtml(payload);
-    if (isVueSuspensePayload(payload) && isPatchedPendingEntry(pendingEntry)) {
-      return;
-    }
-    node.innerHTML = html;
-    node.setAttribute("data-absolute-slot-state", "resolved");
-    window.dispatchEvent(new CustomEvent(SLOT_PATCH_EVENT, {
-      detail: { html, id, payload }
-    }));
-    if (isVueSuspensePayload(payload)) {
-      pending[id] = { domPatched: true, payload };
-      return;
-    }
-    delete pending[id];
-  };
-  const flush = () => {
-    for (const id in pending) {
-      if (!Object.prototype.hasOwnProperty.call(pending, id))
-        continue;
-      apply(id, pending[id] ?? "");
-    }
-  };
-  absoluteWindow.__ABS_SLOT_FLUSH__ = flush;
-  absoluteWindow.__ABS_SLOT_ENQUEUE__ = (id, payload) => {
-    apply(id, payload);
-  };
-  if (typeof MutationObserver === "function") {
-    const observer = new MutationObserver(flush);
-    const root = document.documentElement ?? document.body ?? document;
-    observer.observe(root, { childList: true, subtree: true });
-  }
-  if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", flush, { once: true });
-  }
-  flush();
-}, stripFunctionWrapper = (value) => {
-  const start = value.indexOf("{");
-  const end = value.lastIndexOf("}");
-  if (start < 0 || end <= start)
-    return "";
-  return value.slice(start + 1, end);
-}, getStreamSwapRuntimeScript = () => `(function(){${stripFunctionWrapper(streamSwapRuntime.toString())}})();`;
-
-// src/utils/escapeScriptContent.ts
-var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
-  const escaped = ESCAPE_LOOKUP[char];
-  return escaped !== undefined ? escaped : char;
-});
-var init_escapeScriptContent = __esm(() => {
-  ESCAPE_LOOKUP = {
-    "\u2028": "\\u2028",
-    "\u2029": "\\u2029",
-    "<": "\\u003C"
-  };
-  ESCAPE_REGEX = /[<\u2028\u2029]/g;
-});
-
-// src/utils/streamingSlots.ts
-var SLOT_ID_PREFIX = "abs-slot-", CLOSING_BODY_TAG = "</body>", CLOSING_HEAD_TAG2 = "</head>", CLOSING_BODY_TAG_LENGTH, CLOSING_HEAD_TAG_LENGTH, CLOSING_PAGE_TAG_REGEX, STREAMING_RUNTIME_GLOBAL = "__ABS_SLOT_ENQUEUE__", STREAMING_PENDING_GLOBAL = "__ABS_SLOT_PENDING__", STREAM_TAIL_LOOKBEHIND = 128, STREAMING_SLOT_TIMEOUT_MS = 5000, STREAMING_SLOT_MAX_PER_RESPONSE = 128, STREAMING_SLOT_MAX_HTML_BYTES = 64000, createSlotPatchStatement = (id, payload) => `(window.${STREAMING_RUNTIME_GLOBAL}||function(i,p){window.${STREAMING_PENDING_GLOBAL}=window.${STREAMING_PENDING_GLOBAL}||{};window.${STREAMING_PENDING_GLOBAL}[i]=p;})(${JSON.stringify(id)},${JSON.stringify(payload)});`, createNonceAttr = (nonce) => nonce ? ` nonce="${nonce}"` : "", createStreamingSlotId = () => `${SLOT_ID_PREFIX}${Math.random().toString(BASE_36_RADIX).slice(2, RANDOM_ID_END_INDEX)}`, getStreamingSlotsRuntimeScript = () => getStreamSwapRuntimeScript(), injectHtmlIntoBody = (html, injection) => {
-  const closingBodyIndex = html.indexOf(CLOSING_BODY_TAG);
-  if (closingBodyIndex >= 0) {
-    return `${html.slice(0, closingBodyIndex)}${injection}${html.slice(closingBodyIndex)}`;
-  }
-  return `${html}${injection}`;
-}, injectHtmlIntoHead = (html, injection) => {
-  const closingHeadIndex = html.indexOf(CLOSING_HEAD_TAG2);
-  if (closingHeadIndex >= 0) {
-    return `${html.slice(0, closingHeadIndex)}${injection}${html.slice(closingHeadIndex)}`;
-  }
-  return `${html}${injection}`;
-}, renderStreamingSlotPatchTag = (id, payload, nonce) => `<script${createNonceAttr(nonce)}>${escapeScriptContent(createSlotPatchStatement(id, payload))}</script>`, renderStreamingSlotPlaceholder = (id, fallbackHtml = "") => `<div id="${id}" data-absolute-slot="true" data-absolute-slot-state="fallback">${fallbackHtml}</div>`, renderStreamingSlotsRuntimeTag = (nonce, runtimePreludeScript) => {
-  const runtimeBody = [
-    runtimePreludeScript?.trim() ? runtimePreludeScript.trim() : "",
-    getStreamingSlotsRuntimeScript()
-  ].filter(Boolean).join(";");
-  return `<script${createNonceAttr(nonce)}>${escapeScriptContent(runtimeBody)}</script>`;
-}, toUint8 = (value, encoder) => encoder.encode(value), isRecord = (value) => Boolean(value) && typeof value === "object", isSafeHtmlLike = (value) => isRecord(value) && typeof value.changingThisBreaksApplicationSecurity === "string", normalizeSafeHtml = (value) => {
-  if (isSafeHtmlLike(value)) {
-    return value.changingThisBreaksApplicationSecurity;
-  }
-  return value;
-}, currentStreamingSlotPolicy, clonePolicy = (policy) => ({
-  ...policy
-}), normalizeSlotBytes = (value, fallback) => {
-  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-    return Math.floor(value);
-  }
-  return fallback;
-}, normalizeSlotText = (value, fallback) => {
-  const normalizedValue = normalizeSafeHtml(value);
-  return typeof normalizedValue === "string" ? normalizedValue : fallback;
-}, normalizeSlotError = (value, fallback = undefined) => {
-  const safeValue = normalizeSafeHtml(value);
-  if (typeof safeValue === "string")
-    return safeValue;
-  return fallback;
-}, hasPolicyValue = (policy, key) => Object.prototype.hasOwnProperty.call(policy, key), applyStreamingSlotPolicyOverrides = (base, overridePolicy = {}) => ({
-  errorHtml: hasPolicyValue(overridePolicy, "errorHtml") ? normalizeSlotError(overridePolicy.errorHtml) : base.errorHtml,
-  fallbackHtml: hasPolicyValue(overridePolicy, "fallbackHtml") ? normalizeSlotText(overridePolicy.fallbackHtml, "") : base.fallbackHtml,
-  maxSlotHtmlSizeBytes: hasPolicyValue(overridePolicy, "maxSlotHtmlSizeBytes") ? normalizeSlotBytes(overridePolicy.maxSlotHtmlSizeBytes, base.maxSlotHtmlSizeBytes) : base.maxSlotHtmlSizeBytes,
-  maxSlotsPerResponse: hasPolicyValue(overridePolicy, "maxSlotsPerResponse") ? normalizeSlotBytes(overridePolicy.maxSlotsPerResponse, base.maxSlotsPerResponse) : base.maxSlotsPerResponse,
-  onError: hasPolicyValue(overridePolicy, "onError") ? overridePolicy.onError : base.onError,
-  onSlotMetric: hasPolicyValue(overridePolicy, "onSlotMetric") ? overridePolicy.onSlotMetric : base.onSlotMetric,
-  timeoutMs: hasPolicyValue(overridePolicy, "timeoutMs") ? normalizeSlotBytes(overridePolicy.timeoutMs, base.timeoutMs) : base.timeoutMs
-}), createCombinedSlotErrorHandler = (policyOnError, enhancerOnError) => {
-  if (!policyOnError && !enhancerOnError)
-    return;
-  return (error, slot) => {
-    policyOnError?.(error, slot);
-    enhancerOnError?.(error, slot);
-  };
-}, createCombinedSlotMetricHandler = (policyOnSlotMetric, callOnSlotMetric) => {
-  if (!policyOnSlotMetric && !callOnSlotMetric)
-    return;
-  return (metric) => {
-    policyOnSlotMetric?.(metric);
-    callOnSlotMetric?.(metric);
-  };
-}, resolveStreamingSlotPolicy = (overridePolicy = {}) => {
-  const base = getStreamingSlotPolicy();
-  return applyStreamingSlotPolicyOverrides(base, overridePolicy);
-}, getStreamingSlotPolicy = () => clonePolicy(currentStreamingSlotPolicy), setStreamingSlotPolicy = (policy = {}) => {
-  const base = getStreamingSlotPolicy();
-  currentStreamingSlotPolicy = applyStreamingSlotPolicyOverrides(base, policy);
-}, withStreamingSlotPolicy = async (policy, callback) => {
-  const previous = getStreamingSlotPolicy();
-  setStreamingSlotPolicy(policy);
-  try {
-    return await callback();
-  } finally {
-    currentStreamingSlotPolicy = previous;
-  }
-}, emitSlotMetric = (metric, onSlotMetric) => {
-  onSlotMetric?.(metric);
-}, createTimeoutError = (slot, timeoutMs) => {
-  const error = Object.assign(new Error(`Streaming slot "${slot.id}" timed out after ${timeoutMs}ms`), { __absTimeout: true });
-  return error;
-}, isSlotPatchPayloadObject = (value) => isRecord(value) && ("html" in value), isTimeoutError = (error) => isRecord(error) && error.__absTimeout === true, toStreamingSlot = (slot, policy) => ({
-  errorHtml: slot.errorHtml === undefined ? policy.errorHtml : slot.errorHtml,
-  fallbackHtml: normalizeSlotText(slot.fallbackHtml, policy.fallbackHtml),
-  id: slot.id ?? createStreamingSlotId(),
-  resolve: slot.resolve,
-  timeoutMs: normalizeSlotBytes(slot.timeoutMs, policy.timeoutMs)
-}), prepareSlots = ({
-  policy,
-  slots,
-  onError,
-  onSlotMetric
-}) => {
-  const preparedSlots = slots.map((slot) => toStreamingSlot(slot, policy));
-  const emitPreparedSlotMetric = (slot) => {
-    emitSlotMetric({
-      slotId: slot.id,
-      type: "prepared"
-    }, onSlotMetric);
-  };
-  const dropPreparedSlot = (slot, reason) => {
-    onError?.(new Error(reason), slot);
-    emitSlotMetric({
-      reason,
-      slotId: slot.id,
-      type: "dropped"
-    }, onSlotMetric);
-  };
-  const { maxSlotsPerResponse } = policy;
-  if (maxSlotsPerResponse === 0) {
-    preparedSlots.forEach((slot) => dropPreparedSlot(slot, "maxSlotsPerResponse is 0"));
-    return [];
-  }
-  if (preparedSlots.length <= maxSlotsPerResponse) {
-    preparedSlots.forEach(emitPreparedSlotMetric);
-    return preparedSlots;
-  }
-  const keptSlots = preparedSlots.slice(0, maxSlotsPerResponse);
-  const droppedSlots = preparedSlots.slice(maxSlotsPerResponse);
-  droppedSlots.forEach((slot) => {
-    dropPreparedSlot(slot, `Streaming slot "${slot.id}" dropped because ${maxSlotsPerResponse} slots is the configured maximum`);
-  });
-  keptSlots.forEach(emitPreparedSlotMetric);
-  return keptSlots;
-}, htmlByteLength = (value, encoder) => encoder.encode(value).length, normalizeSlotPatchPayload = (value) => {
-  const safeValue = normalizeSafeHtml(value);
-  if (isSlotPatchPayloadObject(safeValue) && typeof safeValue.html === "string") {
-    return {
-      ...safeValue,
-      html: normalizeSlotText(safeValue.html, "")
-    };
-  }
-  return typeof safeValue === "string" ? safeValue : `${safeValue}`;
-}, getPayloadHtml = (payload) => typeof payload === "string" ? payload : payload.html, enqueueEncodedText = (controller, encoder, value) => {
-  if (value.length === 0) {
-    return;
-  }
-  controller.enqueue(encoder.encode(value));
-}, readStreamingRuntimeChunk = async (reader) => {
-  const { done, value } = await reader.read();
-  if (done || !value) {
-    return { done, value: undefined };
-  }
-  return { done, value };
-}, applyBaseWinnerState = (state, winner, handleResolved) => {
-  if (!state.handled && winner.kind === "slot") {
-    handleResolved(winner);
-  }
-  return state;
-}, resolveOversizedSlotPayload = (input) => {
-  const {
-    encoder,
-    html,
-    maxSlotHtmlSizeBytes,
-    onError,
-    onSlotMetric,
-    slot,
-    start
-  } = input;
-  const bytes = htmlByteLength(html, encoder);
-  if (bytes <= maxSlotHtmlSizeBytes) {
-    return null;
-  }
-  const error = new Error(`Streaming slot "${slot.id}" exceeded max payload size of ${maxSlotHtmlSizeBytes} bytes`);
-  const durationMs = Date.now() - start;
-  onError?.(error, slot);
-  emitSlotMetric({
-    bytes,
-    durationMs,
-    error,
-    slotId: slot.id,
-    type: "size_exceeded"
-  }, onSlotMetric);
-  const fallbackHtml = normalizeSlotError(slot.errorHtml, undefined);
-  return {
-    bytes: fallbackHtml === undefined ? 0 : htmlByteLength(fallbackHtml, encoder),
-    durationMs,
-    id: slot.id,
-    payload: fallbackHtml === undefined ? null : fallbackHtml
-  };
-}, raceWithTimeout = (promise, slot) => {
-  const { timeoutMs } = slot;
-  if (typeof timeoutMs !== "number" || timeoutMs <= 0) {
-    return promise;
-  }
-  const { promise: timeoutPromise, reject } = Promise.withResolvers();
-  setTimeout(() => {
-    reject(createTimeoutError(slot, timeoutMs));
-  }, timeoutMs);
-  return Promise.race([promise, timeoutPromise]);
-}, resolveSlot = async (slot, onError, policy, onSlotMetric) => {
-  const safePolicy = policy ?? getStreamingSlotPolicy();
-  const encoder = new TextEncoder;
-  const start = Date.now();
-  try {
-    const maybeAsyncValue = Promise.resolve(slot.resolve());
-    const resolved = await raceWithTimeout(maybeAsyncValue, slot);
-    const payload = normalizeSlotPatchPayload(resolved);
-    const html = getPayloadHtml(payload);
-    const oversizedResult = safePolicy.maxSlotHtmlSizeBytes > 0 ? resolveOversizedSlotPayload({
-      encoder,
-      html,
-      maxSlotHtmlSizeBytes: safePolicy.maxSlotHtmlSizeBytes,
-      onError,
-      onSlotMetric,
-      slot,
-      start
-    }) : null;
-    if (oversizedResult) {
-      return oversizedResult;
-    }
-    const durationMs = Date.now() - start;
-    const bytes = htmlByteLength(html, encoder);
-    emitSlotMetric({
-      bytes,
-      durationMs,
-      slotId: slot.id,
-      type: "resolved"
-    }, onSlotMetric);
-    return {
-      bytes,
-      durationMs,
-      id: slot.id,
-      payload
-    };
-  } catch (error) {
-    const durationMs = Date.now() - start;
-    onError?.(error, slot);
-    emitSlotMetric({
-      durationMs,
-      error,
-      slotId: slot.id,
-      type: isTimeoutError(error) ? "timeout" : "error"
-    }, onSlotMetric);
-    const html = normalizeSlotError(slot.errorHtml, undefined);
-    if (html) {
-      return {
-        bytes: htmlByteLength(html, encoder),
-        durationMs,
-        id: slot.id,
-        payload: html
-      };
-    }
-    return {
-      bytes: 0,
-      durationMs,
-      id: slot.id,
-      payload: null
-    };
-  }
-}, nextResolvedSlot = async (pending) => {
-  const wrapped = pending.map((promise) => promise.then((result) => ({
-    original: promise,
-    result
-  })));
-  return Promise.race(wrapped);
-}, streamChunkToString2 = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true }), appendStreamingSlotPatchesToStream = (stream, slots = [], {
-  injectRuntime = true,
-  nonce,
-  onError,
-  onSlotMetric,
-  policy,
-  runtimePreludeScript,
-  runtimePlacement = "head"
-} = {}) => {
-  const resolvedPolicy = resolveStreamingSlotPolicy(policy);
-  const combinedOnError = createCombinedSlotErrorHandler(resolvedPolicy.onError, onError);
-  const combinedOnSlotMetric = createCombinedSlotMetricHandler(resolvedPolicy.onSlotMetric, onSlotMetric);
-  const effectivePolicy = {
-    ...resolvedPolicy,
-    onSlotMetric: combinedOnSlotMetric
-  };
-  const preparedSlots = prepareSlots({
-    onError: combinedOnError,
-    onSlotMetric: combinedOnSlotMetric,
-    policy: effectivePolicy,
-    slots
-  });
-  if (preparedSlots.length === 0)
-    return stream;
-  const source = injectRuntime ? injectStreamingRuntimeIntoStream(stream, nonce, runtimePlacement, runtimePreludeScript) : stream;
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const reader = source.getReader();
-  const pending = preparedSlots.map((slot) => resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric));
-  const createRaceCandidates = (baseDone, baseRead) => {
-    const racers = [];
-    if (!baseDone) {
-      racers.push(baseRead.then(({ done, value }) => ({
-        done,
-        kind: "base",
-        value
-      })));
-    }
-    if (pending.length > 0) {
-      racers.push(nextResolvedSlot(pending).then((resolved) => ({
-        kind: "slot",
-        ...resolved
-      })));
-    }
-    return racers;
-  };
-  const flushTailLookbehind = (controller, tail) => {
-    if (tail.length <= STREAM_TAIL_LOOKBEHIND) {
-      return tail;
-    }
-    const content = tail.slice(0, tail.length - STREAM_TAIL_LOOKBEHIND);
-    controller.enqueue(encoder.encode(content));
-    return tail.slice(-STREAM_TAIL_LOOKBEHIND);
-  };
-  const finalizeCompletedBaseWinner = (controller, decodedTail, baseRead) => {
-    const footerStart = decodedTail.search(CLOSING_PAGE_TAG_REGEX);
-    if (footerStart < 0) {
-      enqueueEncodedText(controller, encoder, decodedTail);
-      return {
-        baseDone: true,
-        baseRead,
-        footer: "",
-        handled: true,
-        tail: ""
-      };
-    }
-    const content = decodedTail.slice(0, footerStart);
-    const nextFooter = decodedTail.slice(footerStart);
-    enqueueEncodedText(controller, encoder, content);
-    return {
-      baseDone: true,
-      baseRead,
-      footer: nextFooter,
-      handled: true,
-      tail: ""
-    };
-  };
-  const handleBaseWinner = (controller, winner, baseRead, tail, footer) => {
-    if (winner.kind !== "base") {
-      return { baseDone: false, baseRead, footer, handled: false, tail };
-    }
-    if (winner.done) {
-      return finalizeCompletedBaseWinner(controller, tail + decoder.decode(), baseRead);
-    }
-    if (!winner.value) {
-      return { baseDone: false, baseRead, footer, handled: true, tail };
-    }
-    const nextTail = flushTailLookbehind(controller, tail + streamChunkToString2(winner.value, decoder));
-    return {
-      baseDone: false,
-      baseRead: reader.read(),
-      footer,
-      handled: true,
-      tail: nextTail
-    };
-  };
-  const handleResolvedSlot = (controller, winner) => {
-    const index = pending.indexOf(winner.original);
-    if (index >= 0)
-      pending.splice(index, 1);
-    if (winner.result.payload === null) {
-      return;
-    }
-    emitSlotMetric({
-      bytes: winner.result.bytes,
-      durationMs: winner.result.durationMs,
-      slotId: winner.result.id,
-      type: "patched"
-    }, combinedOnSlotMetric);
-    controller.enqueue(encoder.encode(renderStreamingSlotPatchTag(winner.result.id, winner.result.payload, nonce)));
-  };
-  const runPatchedStreamLoop = async (controller) => {
-    let baseDone = false;
-    let baseRead = reader.read();
-    let tail = "";
-    let footer = "";
-    const readNextRaceWinner = async () => {
-      const racers = createRaceCandidates(baseDone, baseRead);
-      if (racers.length === 0) {
-        return footer;
-      }
-      const winner = await Promise.race(racers);
-      const baseWinnerState = applyBaseWinnerState(handleBaseWinner(controller, winner, baseRead, tail, footer), winner, (slotWinner) => {
-        handleResolvedSlot(controller, slotWinner);
-      });
-      ({ baseDone, baseRead, footer, tail } = baseWinnerState);
-      if (baseDone && pending.length === 0) {
-        return footer;
-      }
-      return readNextRaceWinner();
-    };
-    return readNextRaceWinner();
-  };
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        const footer = await runPatchedStreamLoop(controller);
-        enqueueEncodedText(controller, encoder, footer);
-        controller.close();
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-}, injectStreamingRuntimeIntoStream = (stream, nonce, runtimePlacement = "head", runtimePreludeScript) => {
-  const runtimeTag = renderStreamingSlotsRuntimeTag(nonce, runtimePreludeScript);
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const closingTag = runtimePlacement === "body" ? CLOSING_BODY_TAG : CLOSING_HEAD_TAG2;
-  const lookbehind = (runtimePlacement === "body" ? CLOSING_BODY_TAG_LENGTH : CLOSING_HEAD_TAG_LENGTH) - 1;
-  const flushRuntimeLookbehind = (controller, pending) => {
-    if (pending.length <= lookbehind) {
-      return pending;
-    }
-    const safeText = pending.slice(0, pending.length - lookbehind);
-    controller.enqueue(encoder.encode(safeText));
-    return pending.slice(-lookbehind);
-  };
-  const injectRuntimeIntoPending = (pending) => runtimePlacement === "body" ? injectHtmlIntoBody(pending, runtimeTag) : injectHtmlIntoHead(pending, runtimeTag);
-  const processRuntimePending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
-    }
-    const closingTagIndex = pending.indexOf(closingTag);
-    if (closingTagIndex >= 0) {
-      const withRuntime = `${pending.slice(0, closingTagIndex)}${runtimeTag}${pending.slice(closingTagIndex)}`;
-      controller.enqueue(encoder.encode(withRuntime));
-      return { injected: true, pending: "" };
-    }
-    return {
-      injected,
-      pending: flushRuntimeLookbehind(controller, pending)
-    };
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      let injected = false;
-      let pending = "";
-      const enqueuePending = () => enqueueEncodedText(controller, encoder, pending);
-      const consumeRuntimeChunk = async () => {
-        const { done, value } = await readStreamingRuntimeChunk(reader);
-        if (done || !value) {
-          return done;
-        }
-        pending += streamChunkToString2(value, decoder);
-        ({ injected, pending } = processRuntimePending(controller, pending, injected));
-        return false;
-      };
-      const runRuntimeInjectionLoop = async () => {
-        const done = await consumeRuntimeChunk();
-        if (done) {
-          return;
-        }
-        await runRuntimeInjectionLoop();
-      };
-      try {
-        await runRuntimeInjectionLoop();
-        pending += decoder.decode();
-        pending = injected ? pending : injectRuntimeIntoPending(pending);
-        enqueuePending();
-        controller.close();
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-}, streamOutOfOrderSlots = ({
-  footerHtml = "",
-  headerHtml = "",
-  nonce,
-  policy,
-  onSlotMetric,
-  onError,
-  slots
-}) => {
-  const resolvedPolicy = resolveStreamingSlotPolicy(policy);
-  const combinedOnError = createCombinedSlotErrorHandler(resolvedPolicy.onError, onError);
-  const combinedOnSlotMetric = createCombinedSlotMetricHandler(resolvedPolicy.onSlotMetric, onSlotMetric);
-  const effectivePolicy = {
-    ...resolvedPolicy,
-    onSlotMetric: combinedOnSlotMetric
-  };
-  const preparedSlots = prepareSlots({
-    onError: combinedOnError,
-    onSlotMetric: combinedOnSlotMetric,
-    policy: effectivePolicy,
-    slots
-  });
-  const encoder = new TextEncoder;
-  const createPendingSlots = (controller) => preparedSlots.map((slot) => {
-    const fallback = renderStreamingSlotPlaceholder(slot.id, normalizeSlotText(slot.fallbackHtml, ""));
-    controller.enqueue(toUint8(fallback, encoder));
-    return resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric);
-  });
-  const handleResolvedPreparedSlot = async (controller, pending) => {
-    const { original, result } = await nextResolvedSlot(pending);
-    const index = pending.indexOf(original);
-    if (index >= 0)
-      pending.splice(index, 1);
-    if (result.payload === null) {
-      return;
-    }
-    emitSlotMetric({
-      bytes: result.bytes,
-      durationMs: result.durationMs,
-      slotId: result.id,
-      type: "patched"
-    }, combinedOnSlotMetric);
-    controller.enqueue(toUint8(renderStreamingSlotPatchTag(result.id, result.payload, nonce), encoder));
-  };
-  const streamPreparedSlots = async (controller) => {
-    const pending = createPendingSlots(controller);
-    const streamNextPreparedSlot = async () => {
-      if (pending.length === 0) {
-        return;
-      }
-      await handleResolvedPreparedSlot(controller, pending);
-      await streamNextPreparedSlot();
-    };
-    await streamNextPreparedSlot();
-  };
-  const resolveHeaderHtml = () => {
-    const needsRuntimeTag = preparedSlots.length > 0 && !headerHtml.includes(STREAMING_RUNTIME_GLOBAL);
-    if (!needsRuntimeTag) {
-      return headerHtml;
-    }
-    return injectHtmlIntoHead(headerHtml, renderStreamingSlotsRuntimeTag(nonce));
-  };
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        const header = resolveHeaderHtml();
-        controller.enqueue(toUint8(header, encoder));
-        await streamPreparedSlots(controller);
-        enqueueEncodedText(controller, encoder, footerHtml);
-        controller.close();
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-};
-var init_streamingSlots = __esm(() => {
-  init_constants();
-  init_escapeScriptContent();
-  CLOSING_BODY_TAG_LENGTH = CLOSING_BODY_TAG.length;
-  CLOSING_HEAD_TAG_LENGTH = CLOSING_HEAD_TAG2.length;
-  CLOSING_PAGE_TAG_REGEX = /<\/body>\s*<\/html>\s*$/i;
-  currentStreamingSlotPolicy = {
-    errorHtml: undefined,
-    fallbackHtml: "",
-    maxSlotHtmlSizeBytes: STREAMING_SLOT_MAX_HTML_BYTES,
-    maxSlotsPerResponse: STREAMING_SLOT_MAX_PER_RESPONSE,
-    timeoutMs: STREAMING_SLOT_TIMEOUT_MS
-  };
-});
-
-// 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 {
-    const totalSeconds = Math.round(duration / MILLISECONDS_IN_A_SECOND);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    durationString = seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
-  }
-  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 });
-}, logInfo = (message) => {
-  log(message);
-}, 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/utils/ssrErrorPage.ts
-var exports_ssrErrorPage = {};
-__export(exports_ssrErrorPage, {
-  ssrErrorPage: () => ssrErrorPage
-});
-var ssrErrorPage = (framework, error) => {
-  const frameworkColors2 = {
-    angular: "#dd0031",
-    html: "#e34c26",
-    htmx: "#1a365d",
-    react: "#61dafb",
-    svelte: "#ff3e00",
-    vue: "#42b883"
-  };
-  const accent = frameworkColors2[framework] ?? "#94a3b8";
-  const label = framework.charAt(0).toUpperCase() + framework.slice(1);
-  const message = error instanceof Error ? error.message : String(error);
-  return `<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>SSR Error - AbsoluteJS</title>
-<style>
-*{margin:0;padding:0;box-sizing:border-box}
-body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,rgba(30,41,59,0.98) 100%);color:#e2e8f0;font-family:"JetBrains Mono","Fira Code",ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:14px;line-height:1.6;display:flex;align-items:flex-start;justify-content:center;padding:32px}
-.card{max-width:720px;width:100%;background:rgba(30,41,59,0.6);border:1px solid rgba(71,85,105,0.5);border-radius:16px;box-shadow:0 25px 50px -12px rgba(0,0,0,0.5),0 0 0 1px rgba(255,255,255,0.05);overflow:hidden}
-.header{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:20px 24px;background:rgba(15,23,42,0.5);border-bottom:1px solid rgba(71,85,105,0.4)}
-.brand{font-weight:700;font-size:20px;color:#fff;letter-spacing:-0.02em}
-.badge{padding:5px 10px;border-radius:8px;font-size:12px;font-weight:600;background:${accent};color:#fff;opacity:0.95;box-shadow:0 2px 4px rgba(0,0,0,0.2)}
-.kind{color:#94a3b8;font-size:13px;font-weight:500}
-.content{padding:24px}
-.label{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:0.08em;color:#94a3b8;margin-bottom:8px}
-.message{margin:0;padding:16px 20px;background:rgba(239,68,68,0.12);border:1px solid rgba(239,68,68,0.25);border-radius:10px;overflow-x:auto;white-space:pre-wrap;word-break:break-word;color:#fca5a5;font-size:13px;line-height:1.5}
-.hint{margin-top:20px;padding:12px 20px;background:rgba(71,85,105,0.3);border-radius:10px;border:1px solid rgba(71,85,105,0.4);color:#cbd5e1;font-size:13px}
-</style>
-</head>
-<body>
-<div class="card">
-<div class="header">
-<div style="display:flex;align-items:center;gap:12px">
-<span class="brand">AbsoluteJS</span>
-<span class="badge">${label}</span>
-</div>
-<span class="kind">Server Render Error</span>
-</div>
-<div class="content">
-<div class="label">What went wrong</div>
-<pre class="message">${message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</pre>
-<div class="hint">A component threw during server-side rendering. Check the terminal for the full stack trace.</div>
-</div>
-</div>
-</body>
-</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("");
-};
-
-// 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 renderComponent = render;
-    const rendered = typeof props === "undefined" ? await renderComponent(component) : await renderComponent(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
-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 headLookbehind = CLOSING_HEAD_TAG.length - 1;
-  const enqueue = (controller, text) => {
-    if (text.length > 0) {
-      controller.enqueue(encoder.encode(text));
-    }
-  };
-  const processHolding = (controller, held) => {
-    if (!held.includes(ISLAND_MARKER)) {
-      return { held, injected: false, pending: "", sawHead: true };
-    }
-    enqueue(controller, `${markup}${held}`);
-    return { held: "", injected: true, pending: "", sawHead: true };
-  };
-  const processHead = (controller, pending) => {
-    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
-    if (headIndex < 0) {
-      return {
-        held: "",
-        injected: false,
-        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
-        sawHead: false
-      };
-    }
-    enqueue(controller, pending.slice(0, headIndex));
-    return processHolding(controller, pending.slice(headIndex));
-  };
-  const processChunk = (controller, state, chunk) => {
-    if (state.injected) {
-      enqueue(controller, chunk);
-      return state;
-    }
-    if (!state.sawHead) {
-      return processHead(controller, state.pending + chunk);
-    }
-    return processHolding(controller, state.held + chunk);
-  };
-  const finishMarkerStream = (controller, state) => {
-    const tail = decoder.decode();
-    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
-    enqueue(controller, remainder);
-    controller.close();
-  };
-  const runMarkerLoop = (controller, reader) => {
-    const consumeNext = async (state) => {
-      const { done, value } = await readStreamChunk(reader);
-      if (done || !value) {
-        return state;
-      }
-      return consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
-    };
-    return consumeNext({
-      held: "",
-      injected: false,
-      pending: "",
-      sawHead: false
-    });
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      try {
-        const finalState = await runMarkerLoop(controller, reader);
-        finishMarkerStream(controller, finalState);
-      } 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
-  });
-};
-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()];
-};
-var withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
-  const { result, slots } = await runWithStreamingSlotRegistry(renderResponse);
-  const explicit = options.streamingSlots ?? [];
-  return withStreamingSlots(result, {
-    ...options,
-    streamingSlots: mergeStreamingSlots(slots, explicit)
-  });
-};
-
-// src/core/streamingSlotWarningScope.ts
-init_logger();
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-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;
-};
-var ensureWarningStorage = () => {
-  const existing = getWarningStorage();
-  if (existing) {
-    return existing;
-  }
-  const storage = new AsyncLocalStorage2;
-  Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2, storage);
-  return storage;
-};
-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`;
-};
-var shouldIgnoreWarningFrame = (frame) => frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/react/pageHandler.") || frame.includes("/src/vue/pageHandler.") || frame.includes("/src/svelte/pageHandler.") || frame.includes("/src/angular/pageHandler.") || frame.includes("/src/core/streamingSlotWarningScope.");
-var getWarningLocation = (frame) => frame.match(/\((\/[^)]+:\d+:\d+)\)$/)?.[1] ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/)?.[1];
-var extractCallsiteFromStack = (stack) => {
-  const location = stack.split(`
-`).slice(1).map((line) => line.trim()).filter((frame) => !shouldIgnoreWarningFrame(frame)).map((frame) => getWarningLocation(frame)).find((frameLocation) => frameLocation !== undefined);
-  return location ? normalizeCallsitePath2(location) : undefined;
-};
-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);
-};
-var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
-
-// src/utils/inlinePageCss.ts
-var siblingCssCache = new Map;
-var injectInlineCss = (headTag, css) => {
-  if (!css)
-    return headTag;
-  const styleBlock = `<style data-absolute-page-css>${css}</style>`;
-  return headTag.replace("</head>", `${styleBlock}</head>`);
-};
-var readSiblingCss = async (siblingJsPath) => {
-  if (!siblingJsPath)
-    return "";
-  const cssPath = siblingJsPath.replace(/\.js$/, ".css");
-  if (cssPath === siblingJsPath)
-    return "";
-  const cached = siblingCssCache.get(cssPath);
-  if (cached !== undefined)
-    return cached;
-  const { readFile: readFile2 } = await import("fs/promises");
-  try {
-    const css = await readFile2(cssPath, "utf-8");
-    siblingCssCache.set(cssPath, css);
-    return css;
-  } catch {
-    siblingCssCache.set(cssPath, "");
-    return "";
-  }
-};
-// src/utils/resolveConvention.ts
-import { basename as basename2 } from "path";
-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;
-};
-var derivePageName = (pagePath) => {
-  const base = basename2(pagePath);
-  const dotIndex = base.indexOf(".");
-  const name = dotIndex > 0 ? base.slice(0, dotIndex) : base;
-  return toPascal(name);
-};
-var normalizeConventionPageName = (name) => toPascal(name).replace(/\d+$/, "");
-var hasErrorConvention = (framework) => {
-  const conventions = getMap()[framework];
-  if (!conventions)
-    return false;
-  if (conventions.defaults?.error)
-    return true;
-  return Object.values(conventions.pages ?? {}).some((page) => Boolean(page.error));
-};
-var resolveErrorConventionPath = (framework, pageName) => {
-  const conventions = getMap()[framework];
-  if (!conventions)
-    return;
-  const exact = conventions.pages?.[pageName]?.error;
-  if (exact)
-    return exact;
-  const normalizedPageName = normalizeConventionPageName(pageName);
-  for (const [candidate, page] of Object.entries(conventions.pages ?? {})) {
-    if (normalizeConventionPageName(candidate) === normalizedPageName) {
-      return page.error ?? conventions.defaults?.error;
-    }
-  }
-  return conventions.defaults?.error;
-};
-var resolveNotFoundConventionPath = (framework) => getMap()[framework]?.defaults?.notFound;
-var setConventions = (map) => {
-  Reflect.set(globalThis, CONVENTIONS_KEY, map);
-};
-var isDev = () => true;
-var buildErrorProps = (error) => {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      ...isDev() && error.stack ? { stack: error.stack } : {}
-    };
-  }
-  return { message: String(error), name: "Error" };
-};
-var renderReactError = async (conventionPath, errorProps) => {
-  const { createElement } = await import("react");
-  const { renderToReadableStream } = await import("react-dom/server");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (typeof ErrorComponent !== "function")
-    return null;
-  const element = createElement(ErrorComponent, errorProps);
-  const stream = await renderToReadableStream(element);
-  return new Response(stream, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-var renderSvelteError = async (conventionPath, errorProps) => {
-  const { render } = await import("svelte/server");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (!ErrorComponent)
-    return null;
-  const { head, body } = render(ErrorComponent, {
-    props: errorProps
-  });
-  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-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 };
-};
-var renderVueError = async (conventionPath, errorProps) => {
-  const { createSSRApp, h } = await import("vue");
-  const { renderToString } = await import("vue/server-renderer");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (!ErrorComponent)
-    return null;
-  const app = createSSRApp({
-    render: () => h(ErrorComponent, errorProps)
-  });
-  const rawBody = await renderToString(app);
-  const { styles, body } = unescapeVueStyles(rawBody);
-  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-var renderAngularError = async (conventionPath, errorProps) => {
-  const mod = await import(conventionPath);
-  const renderFn = mod.default;
-  if (typeof renderFn !== "function")
-    return null;
-  const html = renderFn(errorProps);
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-var replaceErrorTokens = (template, errorProps) => template.replace(/\{\{\s*name\s*\}\}/g, escapeHtml(errorProps.name)).replace(/\{\{\s*message\s*\}\}/g, escapeHtml(errorProps.message)).replace(/\{\{\s*stack\s*\}\}/g, errorProps.stack ? escapeHtml(errorProps.stack) : "");
-var renderHtmlError = async (conventionPath, errorProps) => {
-  const template = await Bun.file(conventionPath).text();
-  const html = replaceErrorTokens(template, errorProps);
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-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);
-};
-var renderEmberError = async () => null;
-var renderEmberNotFound = async () => null;
-var ERROR_RENDERERS = {
-  angular: renderAngularError,
-  ember: renderEmberError,
-  html: renderHtmlError,
-  react: renderReactError,
-  svelte: renderSvelteError,
-  vue: renderVueError
-};
-var tryFrameworkErrorConvention = async (framework, pageName, errorProps, error) => {
-  let conventionPath = resolveErrorConventionPath(framework, pageName);
-  if (!conventionPath && error instanceof Error && error.stack) {
-    for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
-      const candidate = match[1];
-      if (!candidate)
-        continue;
-      conventionPath = resolveErrorConventionPath(framework, candidate);
-      if (conventionPath)
-        break;
-    }
-  }
-  if (!conventionPath)
-    return null;
-  const renderer = ERROR_RENDERERS[framework];
-  if (!renderer)
-    return null;
-  try {
-    return await renderer(conventionPath, errorProps);
-  } catch (renderError) {
-    logConventionRenderError(framework, "error", renderError);
-  }
-  return null;
-};
-var renderConventionError = async (framework, pageName, error) => {
-  const errorProps = buildErrorProps(error);
-  const frameworkResponse = await tryFrameworkErrorConvention(framework, pageName, errorProps, error);
-  if (frameworkResponse)
-    return frameworkResponse;
-  if (framework !== "html") {
-    const htmlResponse = await tryFrameworkErrorConvention("html", pageName, errorProps, error);
-    if (htmlResponse)
-      return htmlResponse;
-  }
-  return null;
-};
-var renderReactNotFound = async (conventionPath) => {
-  const { createElement } = await import("react");
-  const { renderToReadableStream } = await import("react-dom/server");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (typeof NotFoundComponent !== "function")
-    return null;
-  const element = createElement(NotFoundComponent);
-  const stream = await renderToReadableStream(element);
-  return new Response(stream, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderSvelteNotFound = async (conventionPath) => {
-  const { render } = await import("svelte/server");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (!NotFoundComponent)
-    return null;
-  const { head, body } = render(NotFoundComponent);
-  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderVueNotFound = async (conventionPath) => {
-  const { createSSRApp, h } = await import("vue");
-  const { renderToString } = await import("vue/server-renderer");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (!NotFoundComponent)
-    return null;
-  const app = createSSRApp({
-    render: () => h(NotFoundComponent)
-  });
-  const rawBody = await renderToString(app);
-  const { styles, body } = unescapeVueStyles(rawBody);
-  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderAngularNotFound = async (conventionPath) => {
-  const mod = await import(conventionPath);
-  const renderFn = mod.default;
-  if (typeof renderFn !== "function")
-    return null;
-  const html = renderFn();
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderHtmlNotFound = async (conventionPath) => {
-  const html = await Bun.file(conventionPath).text();
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var NOT_FOUND_RENDERERS = {
-  angular: renderAngularNotFound,
-  ember: renderEmberNotFound,
-  html: renderHtmlNotFound,
-  react: renderReactNotFound,
-  svelte: renderSvelteNotFound,
-  vue: renderVueNotFound
-};
-var renderConventionNotFound = async (framework) => {
-  const conventionPath = resolveNotFoundConventionPath(framework);
-  if (!conventionPath)
-    return null;
-  const renderer = NOT_FOUND_RENDERERS[framework];
-  if (!renderer)
-    return null;
-  try {
-    return await renderer(conventionPath);
-  } catch (renderError) {
-    logConventionRenderError(framework, "not-found", renderError);
-  }
-  return null;
-};
-var NOT_FOUND_PRIORITY = [
-  "react",
-  "svelte",
-  "vue",
-  "angular",
-  "html"
-];
-var renderFirstNotFound = async () => {
-  const renderNext = async (frameworks) => {
-    const [framework, ...remaining] = frameworks;
-    if (!framework) {
-      return null;
-    }
-    if (!getMap()[framework]?.defaults?.notFound) {
-      return renderNext(remaining);
-    }
-    const response = await renderConventionNotFound(framework);
-    if (response) {
-      return response;
-    }
-    return renderNext(remaining);
-  };
-  return renderNext(NOT_FOUND_PRIORITY);
-};
-
-// src/svelte/pageHandler.ts
-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;
-};
-var readDefaultExport = (value) => isRecord2(value) ? value.default : undefined;
-var primeSvelteStream = async (stream) => {
-  const reader = stream.getReader();
-  const firstChunk = await reader.read();
-  return { firstChunk, reader };
-};
-var restorePrimedStream = (firstChunk, reader) => new ReadableStream({
-  start(controller) {
-    if (!firstChunk.done) {
-      controller.enqueue(firstChunk.value);
-    }
-    if (firstChunk.done) {
-      controller.close();
-      return;
-    }
-    const pumpLoop = () => {
-      reader.read().then(({ done, value }) => done ? controller.close() : (controller.enqueue(value), pumpLoop())).catch((err) => controller.error(err));
-    };
-    pumpLoop();
-  }
-});
-var resolveRequestPathname = (request) => {
-  if (!request)
-    return;
-  try {
-    const parsed = new URL(request.url);
-    return `${parsed.pathname}${parsed.search}`;
-  } catch {
-    return;
-  }
-};
-var handleSveltePageRequest = async (input) => {
-  const resolvedIndexPath = input.indexPath;
-  const resolvedOptions = input;
-  const resolvedPagePath = input.pagePath;
-  const userProps = input.props;
-  const requestPathname = resolveRequestPathname(input.request);
-  const resolvedProps = requestPathname !== undefined && (!userProps || !("url" in userProps)) ? {
-    ...userProps ?? {},
-    url: requestPathname
-  } : userProps;
-  try {
-    const handlerCallsite = resolvedOptions?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
-    const renderPageResponse = async () => {
-      const resolvePageComponent = async () => {
-        const loadCompiledSourcePath = async (sourcePath) => {
-          const compiledModulePath = await compileSvelteServerModule(sourcePath);
-          const loadedModule = await import(compiledModulePath);
-          const loadedComponent = readDefaultExport(loadedModule) ?? loadedModule;
-          if (!isGenericSvelteComponent(loadedComponent)) {
-            throw new Error(`Invalid compiled Svelte page module: ${sourcePath}`);
-          }
-          return {
-            component: loadedComponent,
-            hasIslands: readHasIslands(loadedModule)
-          };
-        };
-        const importedPageModule = await import(resolvedPagePath);
-        const importedPageComponent = readDefaultExport(importedPageModule) ?? importedPageModule;
-        if (typeof importedPageComponent === "string" && importedPageComponent.endsWith(".svelte")) {
-          return loadCompiledSourcePath(importedPageComponent);
-        }
-        if (!isGenericSvelteComponent(importedPageComponent)) {
-          throw new Error(`Invalid Svelte page module: ${resolvedPagePath}`);
-        }
-        return {
-          component: importedPageComponent,
-          hasIslands: readHasIslands(importedPageModule)
-        };
-      };
-      const { renderToReadableStream: renderToReadableStream2 } = await Promise.resolve().then(() => (init_renderToReadableStream(), exports_renderToReadableStream));
-      const resolvedPage = await resolvePageComponent();
-      const siblingCss = await readSiblingCss(resolvedPagePath);
-      const cssBlock = siblingCss ? `<style data-absolute-page-css>${siblingCss}</style>` : "";
-      const composedHeadContent = `${cssBlock}${resolvedOptions?.headContent ?? ""}`;
-      const stream = await renderToReadableStream2(resolvedPage.component, resolvedProps, {
-        bodyContent: resolvedOptions?.bodyContent,
-        bootstrapScriptContent: `window.__ABS_SLOT_HYDRATION_PENDING__=true;window.__INITIAL_PROPS__=${JSON.stringify(resolvedProps)};${resolvedIndexPath ? `import(${JSON.stringify(resolvedIndexPath)});` : ""}`,
-        headContent: composedHeadContent
-      });
-      const htmlStream = injectIslandPageContextStream(stream, {
-        hasIslands: resolvedPage.hasIslands ? true : undefined
-      });
-      const { firstChunk, reader } = await primeSvelteStream(htmlStream);
-      return new Response(restorePrimedStream(firstChunk, reader), {
-        headers: { "Content-Type": "text/html" }
-      });
-    };
-    return await runWithStreamingSlotWarningScope(() => resolvedOptions?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, {
-      ...resolvedOptions,
-      runtimePlacement: resolvedOptions.runtimePlacement ?? "body"
-    }) : renderPageResponse(), { handlerCallsite });
-  } catch (error) {
-    console.error("[SSR] Svelte render error:", error);
-    const pageName = derivePageName(resolvedPagePath);
-    const conventionResponse = await renderConventionError("svelte", pageName, error);
-    if (conventionResponse)
-      return conventionResponse;
-    return new Response(ssrErrorPage("svelte", error), {
-      headers: { "Content-Type": "text/html" },
-      status: 500
-    });
-  }
-};
-export {
-  handleSveltePageRequest
-};
-
-//# debugId=60043A1DAC6A8BBA64756E2164756E21
-//# sourceMappingURL=server.js.map