@absolutejs/absolute 0.19.0-beta.807 → 0.19.0-beta.809

package/dist/vue/index.js

@@ -1,54 +1,4074 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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/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, 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, 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, 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/core/devRouteRegistrationCallsite.ts
+var exports_devRouteRegistrationCallsite = {};
+__export(exports_devRouteRegistrationCallsite, {
+  patchElysiaRouteRegistrationCallsites: () => patchElysiaRouteRegistrationCallsites,
+  getCurrentRouteRegistrationCallsite: () => getCurrentRouteRegistrationCallsite
+});
+import { AsyncLocalStorage } from "async_hooks";
+import { Elysia } from "elysia";
+var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, isObjectRecord4 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage2 = (value) => isObjectRecord4(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) => function patchedRouteMethod(path, handler, ...rest) {
+  const callsite = captureRouteRegistrationCallsite();
+  return Reflect.apply(originalMethod, this, [
+    path,
+    wrapRouteHandlerWithCallsite(handler, callsite),
+    ...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));
+  });
+  Reflect.set(globalThis, ROUTE_CALLSITE_PATCHED_KEY, true);
+};
+var init_devRouteRegistrationCallsite = __esm(() => {
+  ROUTE_CALLSITE_STORAGE_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsiteStorage");
+  ROUTE_CALLSITE_PATCHED_KEY = Symbol.for("absolutejs.devRouteRegistrationCallsitePatched");
+  ROUTE_METHOD_NAMES = [
+    "all",
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put"
+  ];
+});
+
+// src/client/streamSwap.ts
+var streamSwapRuntime = () => {
+  const 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 isObjectRecord5 = (value) => Boolean(value) && typeof value === "object";
+  const isPatchedPendingEntry = (value) => {
+    if (!isObjectRecord5(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 (!isObjectRecord5(payload))
+      return false;
+    return payload.kind === "angular-defer";
+  };
+  const isVueSuspensePayload2 = (payload) => {
+    if (!isObjectRecord5(payload))
+      return false;
+    return payload.kind === "vue-suspense";
+  };
+  const resolveHtml = (payload) => {
+    if (!isObjectRecord5(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 (isVueSuspensePayload2(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 (isVueSuspensePayload2(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 relative = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative = relative.replace(/\\/g, "/");
+  if (!relative.startsWith("/")) {
+    relative = `/${relative}`;
+  }
+  return relative;
+}, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
+  let message = action;
+  if (options?.path) {
+    const pathColor = options.framework ? getFrameworkColor(options.framework) : colors2.white;
+    message += ` ${pathColor}${formatPath(options.path)}${colors2.reset}`;
+  }
+  if (options?.duration !== undefined) {
+    message += ` ${colors2.dim}(${options.duration}ms)${colors2.reset}`;
+  }
+  console.log(`${timestamp} ${tag} ${message}`);
+}, logCssUpdate = (path, framework, duration) => {
+  log("css update", { duration, framework: framework ?? "css", path });
+}, logError = (message, error) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.red}[hmr]${colors2.reset}`;
+  const errorMsg = error instanceof Error ? error.message : error;
+  const fullMessage = `${colors2.red}error${colors2.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
+  console.error(`${timestamp} ${tag} ${fullMessage}`);
+}, logHmrUpdate = (path, framework, duration) => {
+  log("hmr update", { duration, framework, path });
+}, logScriptUpdate = (path, framework, duration) => {
+  log("script update", { duration, framework, path });
+}, logServerReload = () => {
+  log(`${colors2.cyan}server module reloaded${colors2.reset}`);
+}, logWarn = (message) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const tag = `${colors2.yellow}[hmr]${colors2.reset}`;
+  console.log(`${timestamp} ${tag} ${colors2.yellow}warning ${message}${colors2.reset}`);
+};
+var init_logger = __esm(() => {
+  init_startupBanner();
+  colors2 = {
+    blue: "\x1B[34m",
+    bold: "\x1B[1m",
+    cyan: "\x1B[36m",
+    dim: "\x1B[2m",
+    green: "\x1B[32m",
+    magenta: "\x1B[35m",
+    red: "\x1B[31m",
+    reset: "\x1B[0m",
+    white: "\x1B[37m",
+    yellow: "\x1B[33m"
+  };
+  frameworkColors = {
+    angular: colors2.magenta,
+    assets: colors2.dim,
+    css: colors2.cyan,
+    html: colors2.white,
+    htmx: colors2.white,
+    react: colors2.blue,
+    svelte: colors2.yellow,
+    vue: colors2.green
+  };
+});
+
+// src/core/ssrCache.ts
+var dirtyFrameworks, isSsrCacheDirty = (framework) => dirtyFrameworks.has(framework), markSsrCacheDirty = (framework) => {
+  dirtyFrameworks.add(framework);
+};
+var init_ssrCache = __esm(() => {
+  dirtyFrameworks = new Set;
+});
+
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+}, toScreamingSnake = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+
+// src/core/islandManifest.ts
+var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), collectFrameworkIslands = (manifest, prefix) => {
+  const entries = {};
+  let found = false;
+  for (const [key, value] of Object.entries(manifest)) {
+    if (!key.startsWith(prefix))
+      continue;
+    const component = key.slice(prefix.length);
+    if (!component)
+      continue;
+    entries[component] = value;
+    found = true;
+  }
+  return found ? entries : undefined;
+}, getIslandManifestEntries = (manifest) => {
+  const islands = {};
+  const frameworks = ["react", "svelte", "vue", "angular"];
+  for (const framework of frameworks) {
+    const prefix = `Island${toIslandFrameworkSegment(framework)}`;
+    const entries = collectFrameworkIslands(manifest, prefix);
+    if (entries)
+      islands[framework] = entries;
+  }
+  return islands;
+}, getIslandManifestKey = (framework, component) => `Island${toIslandFrameworkSegment(framework)}${component}`;
+
+// src/core/islands.ts
+function getIslandComponent(component) {
+  if (isIslandComponentDefinition(component)) {
+    return component.component;
+  }
+  return component;
+}
+var defineIslandComponent = (component, options) => ({
+  component,
+  export: options.export,
+  source: options.source
+}), defineIslandRegistry = (registry) => registry, isRecord3 = (value) => typeof value === "object" && value !== null, getIslandBuildReference = (component) => {
+  if (!isIslandComponentDefinition(component))
+    return null;
+  return {
+    export: component.export,
+    source: component.source
+  };
+}, isIslandComponentDefinition = (value) => isRecord3(value) && ("component" in value) && ("source" in value) && typeof value.source === "string", parseIslandProps = (rawProps) => {
+  if (!rawProps)
+    return {};
+  return JSON.parse(rawProps);
+}, serializeIslandProps = (props) => JSON.stringify(props ?? {});
+var init_islands = () => {};
+
+// src/core/islandMarkupAttributes.ts
+var getIslandMarkerAttributes = (props, islandId) => ({
+  "data-component": props.component,
+  "data-framework": props.framework,
+  "data-hydrate": props.hydrate ?? "load",
+  "data-island": "true",
+  ...islandId ? { "data-island-id": islandId } : {},
+  "data-props": serializeIslandProps(props.props)
+}), escapeHtmlAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"), serializeIslandAttributes = (attributes) => Object.entries(attributes).map(([key, value]) => `${key}="${escapeHtmlAttribute(value)}"`).join(" ");
+var init_islandMarkupAttributes = __esm(() => {
+  init_islands();
+});
+
+// src/core/currentIslandRegistry.ts
+var requireCurrentIslandRegistry = () => {
+  const registry = globalThis.__absoluteIslandRegistry;
+  if (!registry) {
+    throw new Error("No island registry is active. Configure `islands.registry` in absolute.config.ts before rendering <Island />.");
+  }
+  return registry;
+}, setCurrentIslandRegistry = (registry) => {
+  globalThis.__absoluteIslandRegistry = registry;
+};
+
+// src/angular/resolveAngularPackage.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+var resolveAngularPackageDir = (specifier) => {
+  const fromCompiledRuntime = process.env.ABSOLUTE_BUILD_DIR ? resolve(process.env.ABSOLUTE_BUILD_DIR, "node_modules", specifier) : null;
+  if (fromCompiledRuntime && existsSync(fromCompiledRuntime)) {
+    return fromCompiledRuntime;
+  }
+  const fromProject = resolve(process.cwd(), "node_modules", specifier);
+  if (existsSync(fromProject)) {
+    return fromProject;
+  }
+  return null;
+}, resolvePackageEntry = (packageDir) => {
+  try {
+    const pkg = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
+    const rootExport = pkg.exports?.["."];
+    const entry = (typeof rootExport === "string" ? rootExport : rootExport?.default) ?? pkg.module ?? pkg.main ?? "index.js";
+    return join(packageDir, entry);
+  } catch {
+    return packageDir;
+  }
+}, resolveAngularPackage = (specifier) => {
+  const packageDir = resolveAngularPackageDir(specifier);
+  if (packageDir)
+    return resolvePackageEntry(packageDir);
+  return specifier;
+}, toSafeVendorName = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), resolveAngularRuntimePath = (specifier) => {
+  const buildDir = process.env.ABSOLUTE_BUILD_DIR;
+  if (buildDir) {
+    const vendorPath = join(buildDir, "angular", "vendor", "server", `${toSafeVendorName(specifier)}.js`);
+    if (existsSync(vendorPath))
+      return vendorPath;
+  }
+  return resolveAngularPackage(specifier);
+};
+var init_resolveAngularPackage = () => {};
+
+// src/angular/angularPatch.ts
+var exports_angularPatch = {};
+__export(exports_angularPatch, {
+  applyPatches: () => applyPatches
+});
+var ensureHead = (doc) => {
+  if (!doc || doc.head || !doc.documentElement) {
+    return;
+  }
+  const head = doc.createElement("head");
+  doc.documentElement.insertBefore(head, doc.documentElement.firstChild);
+}, SSR_LAYOUT_RECT, layoutPatchApplied = false, collectPrototypeChain = (instance) => {
+  const protos = [];
+  let current = instance ? Object.getPrototypeOf(instance) : null;
+  while (current && current !== Object.prototype) {
+    protos.push(current);
+    current = Object.getPrototypeOf(current);
+  }
+  return protos;
+}, patchElementLayout = (doc) => {
+  if (layoutPatchApplied || !doc) {
+    return;
+  }
+  let element;
+  try {
+    element = doc.createElement("div");
+  } catch {
+    return;
+  }
+  const protos = collectPrototypeChain(element);
+  if (protos.length === 0)
+    return;
+  const copyLayoutRect = (rect) => ({ ...rect });
+  const createLayoutRect = () => copyLayoutRect(SSR_LAYOUT_RECT);
+  const getClientRects = () => [];
+  const noop = () => {
+    return;
+  };
+  const numericProps = [
+    "clientWidth",
+    "clientHeight",
+    "clientLeft",
+    "clientTop",
+    "offsetWidth",
+    "offsetHeight",
+    "offsetLeft",
+    "offsetTop",
+    "scrollWidth",
+    "scrollHeight",
+    "scrollLeft",
+    "scrollTop"
+  ];
+  for (const proto of protos) {
+    const define = (name, value) => {
+      const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+      if (typeof descriptor?.value === "function")
+        return;
+      Object.defineProperty(proto, name, {
+        configurable: true,
+        value,
+        writable: true
+      });
+    };
+    define("getBoundingClientRect", createLayoutRect);
+    define("getClientRects", getClientRects);
+    define("scrollTo", noop);
+    define("scrollBy", noop);
+    define("scrollIntoView", noop);
+    define("focus", noop);
+    define("blur", noop);
+    for (const prop of numericProps) {
+      const desc = Object.getOwnPropertyDescriptor(proto, prop);
+      if (desc)
+        continue;
+      Object.defineProperty(proto, prop, {
+        configurable: true,
+        get: () => 0
+      });
+    }
+  }
+  layoutPatchApplied = true;
+}, applyPatches = async () => {
+  const { \u{275}DominoAdapter } = await import(resolveAngularRuntimePath("@angular/platform-server"));
+  if (!\u{275}DominoAdapter?.prototype) {
+    console.warn("[Angular Patch] \u0275DominoAdapter not found, skipping patches");
+    return false;
+  }
+  try {
+    const adapter = new \u{275}DominoAdapter;
+    const seedDoc = typeof adapter.createHtmlDocument === "function" ? adapter.createHtmlDocument() : typeof adapter.getDefaultDocument === "function" ? adapter.getDefaultDocument() : null;
+    if (seedDoc) {
+      patchElementLayout(seedDoc);
+      const probe = seedDoc.createElement("div");
+      if (typeof probe.getBoundingClientRect !== "function") {
+        console.warn("[Angular Patch] Layout shim did not stick on probe element prototype chain");
+      }
+    }
+  } catch (error) {
+    console.warn("[Angular Patch] Could not eagerly patch Element prototypes:", error);
+  }
+  const proto = \u{275}DominoAdapter.prototype;
+  const origGetBaseHref = proto.getBaseHref;
+  proto.getBaseHref = function(doc) {
+    if (!doc || !doc.head || typeof doc.head.children === "undefined") {
+      return "";
+    }
+    return origGetBaseHref.call(this, doc);
+  };
+  const origCreateHtmlDocument = proto.createHtmlDocument;
+  proto.createHtmlDocument = function() {
+    const doc = origCreateHtmlDocument.call(this);
+    ensureHead(doc);
+    patchElementLayout(doc);
+    return doc;
+  };
+  const origGetDefaultDocument = proto.getDefaultDocument;
+  proto.getDefaultDocument = function() {
+    const doc = origGetDefaultDocument.call(this);
+    ensureHead(doc);
+    patchElementLayout(doc);
+    return doc;
+  };
+  return true;
+};
+var init_angularPatch = __esm(() => {
+  init_resolveAngularPackage();
+  SSR_LAYOUT_RECT = Object.freeze({
+    bottom: 0,
+    height: 0,
+    left: 0,
+    right: 0,
+    top: 0,
+    width: 0,
+    x: 0,
+    y: 0,
+    toJSON() {
+      return this;
+    }
+  });
+});
+
+// src/angular/angularDeps.ts
+var initDominoAdapter = (platformServer) => {
+  try {
+    platformServer.\u{275}DominoAdapter?.makeCurrent?.();
+  } catch (err) {
+    console.error("Failed to initialize DominoAdapter:", err);
+  }
+}, loadAngularDeps = async () => {
+  if (true) {
+    await import(resolveAngularRuntimePath("@angular/compiler"));
+  }
+  const { applyPatches: applyPatches2 } = await Promise.resolve().then(() => (init_angularPatch(), exports_angularPatch));
+  await applyPatches2();
+  const [platformBrowser, platformServer, common, core] = await Promise.all([
+    import(resolveAngularRuntimePath("@angular/platform-browser")),
+    import(resolveAngularRuntimePath("@angular/platform-server")),
+    import(resolveAngularRuntimePath("@angular/common")),
+    import(resolveAngularRuntimePath("@angular/core"))
+  ]);
+  if (false) {}
+  initDominoAdapter(platformServer);
+  return {
+    APP_BASE_HREF: common.APP_BASE_HREF,
+    bootstrapApplication: platformBrowser.bootstrapApplication,
+    DomSanitizer: platformBrowser.DomSanitizer,
+    ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
+    inject: core.inject,
+    provideClientHydration: platformBrowser.provideClientHydration,
+    provideServerRendering: platformServer.provideServerRendering,
+    provideZonelessChangeDetection: core.provideZonelessChangeDetection,
+    reflectComponentType: core.reflectComponentType,
+    renderApplication: platformServer.renderApplication,
+    REQUEST: core.REQUEST,
+    REQUEST_CONTEXT: core.REQUEST_CONTEXT,
+    RESPONSE_INIT: core.RESPONSE_INIT,
+    Sanitizer: core.Sanitizer,
+    SecurityContext: core.SecurityContext,
+    withHttpTransferCacheOptions: platformBrowser.withHttpTransferCacheOptions
+  };
+}, angularDeps = null, getAngularDeps = () => {
+  if (!angularDeps) {
+    angularDeps = loadAngularDeps();
+  }
+  return angularDeps;
+};
+var init_angularDeps = __esm(() => {
+  init_resolveAngularPackage();
+});
+
+// src/utils/registerClientScript.ts
+var scriptRegistry, requestCounter = 0, getRequestId = () => `req_${Date.now()}_${++requestCounter}`, ssrContextGetter = null, getSsrContextId = () => ssrContextGetter?.() || Object.getOwnPropertyDescriptor(globalThis, "__absolutejs_requestId")?.value, registerClientScript = (script, requestId) => {
+  const id = requestId || getSsrContextId() || getRequestId();
+  if (!scriptRegistry.has(id)) {
+    scriptRegistry.set(id, new Set);
+  }
+  scriptRegistry.get(id)?.add(script);
+  return id;
+}, setSsrContextGetter = (getter) => {
+  ssrContextGetter = getter;
+}, clearAllClientScripts = () => {
+  scriptRegistry.clear();
+}, generateClientScriptCode = (scripts) => {
+  if (scripts.length === 0) {
+    return "";
+  }
+  const scriptCode = scripts.map((script, index) => {
+    const funcString = script.toString();
+    const bodyMatch = funcString.match(/\{([\s\S]*)\}/);
+    if (!bodyMatch || !bodyMatch[1]) {
+      return "";
+    }
+    const body = bodyMatch[1].trim();
+    return `
+	(function() {
+		var executed = false;
+		function executeScript_${index}() {
+			if (executed) return;
+			executed = true;
+			${body}
+		}
+
+		if (document.readyState === 'complete' || document.readyState === 'interactive') {
+			executeScript_${index}();
+		} else {
+			document.addEventListener('DOMContentLoaded', executeScript_${index});
+		}
+
+		// Watch for hydration-added elements
+		var observer = new MutationObserver(function() {
+			executeScript_${index}();
+			if (executed) observer.disconnect();
+		});
+		if (!executed) {
+			observer.observe(document.body || document.documentElement, { childList: true, subtree: true });
+		}
+
+		// Single fallback timeout
+		setTimeout(function() {
+			executeScript_${index}();
+			observer.disconnect();
+		}, 1000);
+	})();`;
+  }).join(`
+`);
+  return `<script>
+(function() {
+${scriptCode}
+})();
+</script>`;
+}, getAndClearClientScripts = (requestId) => {
+  const id = requestId || ssrContextGetter?.();
+  if (!id)
+    return [];
+  const scripts = scriptRegistry.get(id);
+  if (!scripts) {
+    return [];
+  }
+  const scriptArray = Array.from(scripts);
+  scriptRegistry.delete(id);
+  return scriptArray;
+};
+var init_registerClientScript = __esm(() => {
+  scriptRegistry = new Map;
+  if (typeof globalThis !== "undefined") {
+    Object.assign(globalThis, { registerClientScript });
+  }
+});
+
+// src/angular/httpTransferCache.ts
+var ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER = "x-skip-transfer-cache", buildAbsoluteHttpTransferCacheOptions = (options = {}) => {
+  const {
+    filter: userFilter,
+    skipHeader = ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER,
+    ...angularOptions
+  } = options;
+  return {
+    includePostRequests: false,
+    includeRequestsWithAuthHeaders: false,
+    ...angularOptions,
+    filter: (request) => !request.headers.has(skipHeader) && (userFilter?.(request) ?? true)
+  };
+};
+
+// src/angular/requestProviders.ts
+import { REQUEST, REQUEST_CONTEXT, RESPONSE_INIT } from "@angular/core";
+var buildRequestProviders = (deps, request, requestContext, responseInit) => [
+  { provide: deps.REQUEST, useValue: request ?? null },
+  { provide: deps.REQUEST_CONTEXT, useValue: requestContext ?? null },
+  { provide: deps.RESPONSE_INIT, useValue: responseInit ?? null }
+];
+var init_requestProviders = () => {};
+
+// src/angular/ssrRender.ts
+var routePropsCache, cacheRouteData = (pagePath, data) => {
+  const cacheKey = pagePath.split("?")[0] ?? pagePath;
+  routePropsCache.set(cacheKey, data);
+}, getCachedRouteData = (pagePath) => routePropsCache.get(pagePath), selectorCache, buildProviders = (deps, sanitizer, maybeProps, tokenMap, request, requestContext, responseInit, userProviders = []) => {
+  const providers = [
+    deps.provideServerRendering(),
+    deps.provideClientHydration(deps.withHttpTransferCacheOptions(buildAbsoluteHttpTransferCacheOptions())),
+    deps.provideZonelessChangeDetection(),
+    { provide: deps.APP_BASE_HREF, useValue: "/" },
+    {
+      provide: deps.DomSanitizer,
+      useValue: sanitizer
+    },
+    { provide: deps.Sanitizer, useValue: sanitizer },
+    ...buildRequestProviders(deps, request, requestContext, responseInit),
+    ...userProviders
+  ];
+  if (!maybeProps) {
+    return providers;
+  }
+  const propProviders = Object.entries(maybeProps).map(([propName, propValue]) => ({
+    token: tokenMap.get(toScreamingSnake(propName)),
+    value: propValue
+  })).filter((entry) => entry.token).map((entry) => ({ provide: entry.token, useValue: entry.value }));
+  return [...providers, ...propProviders];
+}, clearSelectorCache = () => selectorCache.clear(), isInjectionToken = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return "ngMetadataName" in value && value.ngMetadataName === "InjectionToken";
+}, discoverTokens = (pageModule) => new Map(Object.entries(pageModule).filter(([, value]) => isInjectionToken(value))), resolveSelector = (deps, pagePath, PageComponent) => {
+  const cached = selectorCache.get(pagePath);
+  if (cached) {
+    return cached;
+  }
+  const selector = deps.reflectComponentType(PageComponent)?.selector ?? "ng-app";
+  selectorCache.set(pagePath, selector);
+  return selector;
+}, injectBeforeClose = (html, snippet) => {
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}</body>`);
+  }
+  if (html.includes("</html>")) {
+    return html.replace("</html>", `${snippet}</html>`);
+  }
+  return html + snippet;
+}, injectSsrScripts = (html, requestId, indexPath, props) => {
+  let result = html;
+  const registeredScripts = getAndClearClientScripts(requestId);
+  if (registeredScripts.length > 0) {
+    result = injectBeforeClose(result, generateClientScriptCode(registeredScripts));
+  }
+  if (props) {
+    result = injectBeforeClose(result, `<script>window.__ABS_ANGULAR_PAGE_PROPS__ = ${JSON.stringify(props)};</script>`);
+  }
+  if (indexPath) {
+    const escapedIndexPath = JSON.stringify(indexPath);
+    result = injectBeforeClose(result, `<script>import(${escapedIndexPath});</script>`);
+  }
+  return result;
+}, renderAngularApp = async (deps, PageComponent, providers, document2, url = "/") => {
+  const bootstrap = (context) => deps.bootstrapApplication(PageComponent, { providers }, context);
+  return withSuppressedAngularDevLogs(() => deps.renderApplication(bootstrap, {
+    document: document2,
+    platformProviders: [],
+    url
+  }));
+}, withSuppressedAngularDevLogs = async (render) => {
+  const origLog = console.log;
+  console.log = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("development mode")) {
+      return;
+    }
+    origLog.apply(console, args);
+  };
+  try {
+    return await render();
+  } finally {
+    console.log = origLog;
+  }
+};
+var init_ssrRender = __esm(() => {
+  init_registerClientScript();
+  init_requestProviders();
+  routePropsCache = new Map;
+  selectorCache = new Map;
+});
+
+// src/angular/islands.ts
+var exports_islands = {};
+__export(exports_islands, {
+  renderAngularIslandToHtml: () => renderAngularIslandToHtml,
+  mountAngularIsland: () => mountAngularIsland,
+  isAngularComponent: () => isAngularComponent,
+  getAngularIslandSelector: () => getAngularIslandSelector
+});
+var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) => typeof value === "function", getAngularIslandSelector = (_islandId) => angularIslandSelector, getSelectorFromRenderedIsland = (rootElement) => {
+  const firstChild = rootElement.firstElementChild;
+  if (!(firstChild instanceof HTMLElement)) {
+    return null;
+  }
+  const selector = firstChild.tagName.toLowerCase();
+  return selector.length > 0 ? selector : null;
+}, getClientAngularComponentSelector = (component) => {
+  const maybeDef = Reflect.get(component, "\u0275cmp");
+  if (typeof maybeDef !== "object" || maybeDef === null) {
+    return null;
+  }
+  const maybeSelectors = Reflect.get(maybeDef, "selectors");
+  if (!Array.isArray(maybeSelectors)) {
+    return null;
+  }
+  const [firstSelectorGroup] = maybeSelectors;
+  if (!Array.isArray(firstSelectorGroup)) {
+    return null;
+  }
+  const [selector] = firstSelectorGroup;
+  return typeof selector === "string" && selector.length > 0 ? selector : null;
+}, createAngularIslandApp = async () => {
+  const { EnvironmentInjector, provideZonelessChangeDetection } = await import("@angular/core");
+  const { createApplication } = await import("@angular/platform-browser");
+  const app = await createApplication({
+    providers: [provideZonelessChangeDetection()]
+  });
+  const environmentInjector = app.injector.get(EnvironmentInjector);
+  return { app, environmentInjector };
+}, angularIslandAppPromise = null, getAngularIslandApp = async () => {
+  if (!angularIslandAppPromise) {
+    angularIslandAppPromise = createAngularIslandApp();
+  }
+  return angularIslandAppPromise;
+}, wrapperMetadataCache, requestRenderCache, getRequestRenderCache = () => {
+  const requestId = getSsrContextId();
+  if (!requestId) {
+    return null;
+  }
+  const cached = requestRenderCache.get(requestId);
+  if (cached) {
+    return cached;
+  }
+  const renderCache = new Map;
+  requestRenderCache.set(requestId, renderCache);
+  return renderCache;
+}, getAngularIslandWrapperKey = (component, _islandId) => {
+  const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
+  return `${componentName}:${angularIslandSelector}`;
+}, getIslandRenderCacheKey = (component, props) => {
+  const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
+  return `${componentName}:${JSON.stringify(props)}`;
+}, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
+  const { Component, InjectionToken, inject } = await import("@angular/core");
+  const { NgComponentOutlet } = await import("@angular/common");
+  const deps = await getAngularDeps();
+  const selector = getAngularIslandSelector(islandId);
+  const propsToken = new InjectionToken(`${wrapperKey}:props`);
+
+  class AngularIslandWrapperComponent {
+    component = component;
+    props = inject(propsToken);
+  }
+  return {
+    deps,
+    propsToken,
+    selector,
+    WrapperComponent: Component({
+      imports: [NgComponentOutlet, component],
+      selector,
+      standalone: true,
+      template: '<ng-container *ngComponentOutlet="component; inputs: props"></ng-container>'
+    })(AngularIslandWrapperComponent)
+  };
+}, createAngularIslandWrapper = async (component, islandId) => {
+  const wrapperKey = getAngularIslandWrapperKey(component, islandId);
+  const cached = wrapperMetadataCache.get(wrapperKey);
+  if (cached) {
+    return cached;
+  }
+  const metadataPromise = buildAngularIslandWrapperMetadata(component, islandId, wrapperKey);
+  wrapperMetadataCache.set(wrapperKey, metadataPromise);
+  return metadataPromise;
+}, extractAngularIslandRoot = (html, selector) => {
+  const openTag = `<${selector}`;
+  const start = html.indexOf(openTag);
+  if (start < 0) {
+    throw new Error(`Could not find Angular island root "${selector}".`);
+  }
+  const endTag = `</${selector}>`;
+  const end = html.indexOf(endTag, start);
+  if (end < 0) {
+    throw new Error(`Could not close Angular island root "${selector}".`);
+  }
+  return html.slice(start, end + endTag.length);
+}, mountAngularIsland = async (component, element, props, islandId) => {
+  await import("@angular/compiler");
+  const { createComponent, inputBinding } = await import("@angular/core");
+  const selector = getAngularIslandSelector(islandId);
+  const { app, environmentInjector } = await getAngularIslandApp();
+  let rootElement = element.querySelector(selector);
+  if (!(rootElement instanceof HTMLElement)) {
+    element.innerHTML = `<${selector}></${selector}>`;
+    rootElement = element.querySelector(selector);
+  }
+  if (!(rootElement instanceof HTMLElement))
+    return app;
+  const componentSelector = getClientAngularComponentSelector(component) ?? getSelectorFromRenderedIsland(rootElement);
+  if (!componentSelector)
+    return app;
+  rootElement.innerHTML = `<${componentSelector}></${componentSelector}>`;
+  const hostElement = rootElement.querySelector(componentSelector);
+  if (!(hostElement instanceof HTMLElement))
+    return app;
+  const bindings = Object.entries(props).map(([key, value]) => inputBinding(key, () => value));
+  const componentRef = createComponent(component, {
+    bindings,
+    environmentInjector,
+    hostElement
+  });
+  app.attachView(componentRef.hostView);
+  componentRef.changeDetectorRef.detectChanges();
+  window.__ABS_ANGULAR_ISLAND_APPS__ ??= [];
+  window.__ABS_ANGULAR_ISLAND_APPS__.push(app);
+  return app;
+}, renderAngularIslandToHtml = async (component, props, islandId) => {
+  const requestCache = getRequestRenderCache();
+  const renderCacheKey = getIslandRenderCacheKey(component, props);
+  const cachedHtml = requestCache?.get(renderCacheKey);
+  if (cachedHtml) {
+    return cachedHtml;
+  }
+  const { deps, propsToken, selector, WrapperComponent } = await createAngularIslandWrapper(component, islandId);
+  const providers = [
+    deps.provideServerRendering(),
+    deps.provideZonelessChangeDetection(),
+    { provide: deps.APP_BASE_HREF, useValue: "/" },
+    { provide: propsToken, useValue: props }
+  ];
+  const document2 = `<!DOCTYPE html><html><body><${selector}></${selector}></body></html>`;
+  const html = await withSuppressedAngularDevLogs(() => deps.renderApplication((context) => deps.bootstrapApplication(WrapperComponent, { providers }, context), {
+    document: document2,
+    platformProviders: [],
+    url: "/"
+  }));
+  const islandHtml = extractAngularIslandRoot(html, selector);
+  requestCache?.set(renderCacheKey, islandHtml);
+  return islandHtml;
+};
+var init_islands2 = __esm(() => {
+  init_angularDeps();
+  init_ssrRender();
+  init_registerClientScript();
+  wrapperMetadataCache = new Map;
+  requestRenderCache = new Map;
+});
+
+// src/core/islandSsr.ts
+var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
+  const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands2(), exports_islands));
+  return renderAngularIslandToHtml2(component, props, islandId);
+}, renderAngularIslandToHtml2, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToStaticMarkup }) => renderToStaticMarkup(createElement(component, props)))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
+  const { body } = render(component, { props });
+  return body;
+}), renderVueIslandToHtml = (component, props) => import("vue").then(({ createSSRApp, h: createVueVNode }) => {
+  const app = createSSRApp({
+    render: () => createVueVNode(component, props)
+  });
+  return import("vue/server-renderer").then(({ renderToString }) => renderToString(app));
+});
+var init_islandSsr = __esm(() => {
+  renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
+});
+
+// src/build/resolvePackageImport.ts
+import { resolve as resolve2, join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } 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 = resolve2(process.cwd(), "package.json");
+  const currentPackageJson = existsSync2(currentPackageJsonPath) ? JSON.parse(readFileSync2(currentPackageJsonPath, "utf-8")) : null;
+  const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
+  const packageDir = currentPackageDir ?? resolve2(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (!existsSync2(packageJsonPath))
+    return null;
+  try {
+    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync2(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 = resolve2(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      if (existsSync2(sourceCandidate)) {
+        return sourceCandidate;
+      }
+    }
+    const resolved = resolve2(packageDir, importPath);
+    return existsSync2(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+};
+var init_resolvePackageImport = () => {};
+
+// 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 existsSync3, readFileSync as readFileSync3 } from "fs";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
 import {
-  useIslandStore
-} from "../chunk-tx9edm1x.js";
-import {
-  handleVuePageRequest
-} from "../chunk-e3r9fxaa.js";
-import {
-  StreamSlot,
-  SuspenseSlot
-} from "../chunk-g15qj669.js";
-import {
-  Image
-} from "../chunk-9c5tj4k3.js";
-import"../chunk-798spvzv.js";
-import"../chunk-gd6wmknh.js";
-import"../chunk-mtgf69xn.js";
-import"../chunk-v5vmsxmy.js";
-import"../chunk-c1jfjnka.js";
-import"../chunk-d9c0am65.js";
-import"../chunk-cbkrwmvh.js";
-import {
-  requireCurrentIslandRegistry
-} from "../chunk-5003emhv.js";
-import"../chunk-sd39p726.js";
-import"../chunk-gf0ygptk.js";
-import"../chunk-851whwc7.js";
-import"../chunk-qxq2zcty.js";
-import {
-  preserveIslandMarkup
-} from "../chunk-fak944et.js";
-import"../chunk-s6defjk2.js";
-import"../chunk-p5504p14.js";
-import {
-  renderIslandResult
-} from "../chunk-9j59emg3.js";
-import"../chunk-9ve9jq72.js";
-import"../chunk-7fw6x3js.js";
-import"../chunk-mbazhahf.js";
-import"../chunk-xnt8c6h2.js";
-import"../chunk-qh75agse.js";
+  dirname as dirname2,
+  extname,
+  isAbsolute,
+  join as join3,
+  relative,
+  resolve as resolve3
+} from "path";
+import { fileURLToPath } 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 = []) => [
+  dirname2(filePath),
+  process.cwd(),
+  ...paths.map((path) => resolve3(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 = resolve3(cwd, "tsconfig.json");
+  const empty = { aliases: [], baseUrl: cwd, cwd };
+  if (!existsSync3(tsconfigPath)) {
+    tsconfigAliasCache = empty;
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const baseUrl = resolve3(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(resolve3(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}`,
+    join3(basePath, `index${extension}`)
+  ]);
+  if (language === "scss" || language === "sass") {
+    return paths.flatMap((path) => {
+      const dir = dirname2(path);
+      const base = path.slice(dir.length + 1);
+      return [path, join3(dir, `_${base}`)];
+    });
+  }
+  return paths;
+}, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
+  const rawCandidates = [
+    ...resolveAliasTargets(specifier, config),
+    isAbsolute(specifier) ? specifier : resolve3(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve3(path, specifier))
+  ];
+  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
+    if (existsSync3(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 = dirname2(sourceFile);
+  const entryDir = dirname2(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, resolve3(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, dirname2(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 = resolve3(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 ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
+    const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
+    return resolved ? new URL(`file://${resolved}`) : 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(readFileSync3(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, resolve3(currentDirectory), loadPaths, "less", config));
+    manager.loadFile = async (filename, currentDirectory) => {
+      const resolved = resolveImportPath(filename, resolve3(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(resolve3(dep));
+        }
+      }
+      resolveCss(css ?? "");
+    });
+  });
+}, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
+  const key = resolve3(entry);
+  const stripped = new Set;
+  for (const dep of deps) {
+    const resolved = resolve3(dep);
+    if (resolved !== key)
+      stripped.add(resolved);
+  }
+  styleDependencyGraph.set(key, stripped);
+}, addStyleImporter = (importerPath, stylePath) => {
+  const key = resolve3(importerPath);
+  const target = resolve3(stylePath);
+  const deps = styleDependencyGraph.get(key) ?? new Set;
+  deps.add(target);
+  styleDependencyGraph.set(key, deps);
+}, findStyleEntriesImporting = (changedPath) => {
+  const target = resolve3(changedPath);
+  const importers = [];
+  for (const [entry, deps] of styleDependencyGraph) {
+    if (deps.has(target))
+      importers.push(entry);
+  }
+  return importers;
+}, recordStyleOutput = (entry, css) => {
+  const key = resolve3(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 = resolve3(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(`file://${filePath}`)
+      });
+      const css = await runPostcss(result.css, filePath, config);
+      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)
+    };
+  }
+}), compileStyleFileIfNeeded = async (filePath, config) => {
+  if (!isPreprocessableStylePath(filePath)) {
+    return runPostcss(await readFile(filePath, "utf-8"), filePath, config);
+  }
+  return compileStyleSource(filePath, undefined, undefined, config);
+}, compileStyleFileIfNeededSync = (filePath, config) => {
+  const rawContents = readFileSync3(filePath, "utf-8");
+  const language = getStyleLanguage(filePath);
+  if (config?.postcss) {
+    throw new Error(`Unable to compile ${filePath}: PostCSS preprocessing is async-only.`);
+  }
+  if (language === "scss" || language === "sass") {
+    const options = getSassOptions(config, language);
+    const packageName = options.implementation ?? "sass";
+    let sass;
+    try {
+      sass = requireOptionalPeerSync(packageName);
+    } catch {
+      throw missingDependencyError(packageName, filePath);
+    }
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
+    return sass.compileString(contents, {
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
+      style: "expanded",
+      syntax: language === "sass" ? "indented" : "scss",
+      url: new URL(`file://${filePath}`)
+    }).css;
+  }
+  if (language === "less") {
+    throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  if (language === "stylus") {
+    throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  return rawContents;
+}, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
+var init_stylePreprocessor = __esm(() => {
+  CSS_EXTENSION_PATTERN = /\.css$/i;
+  STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less|styl(?:us)?)$/i;
+  STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
+  STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
+  importOptionalPeer = new Function("specifier", "return import(specifier)");
+  requireOptionalPeer = new Function("specifier", "return require(specifier)");
+  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
+  styleDependencyGraph = new Map;
+  styleOutputHashes = new Map;
+  stylePreprocessorPlugin = createStylePreprocessorPlugin();
+});
+
+// src/core/svelteServerModule.ts
+import { mkdir, readdir as readdir2 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, extname as extname2, join as join4, relative as relative2, resolve as resolve4 } from "path";
+var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
+  const importPath = relative2(dirname3(from), target).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
+  for (const entry of entries) {
+    const entryPath = join4(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 readdir2(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) => basename3(sourcePath).replace(/-[a-z0-9]{6,}(?=\.svelte$)/i, ""), resolveOriginalSourcePath = async (sourcePath) => {
+  const cachedPath = originalSourcePathCache.get(sourcePath);
+  if (cachedPath !== undefined) {
+    return cachedPath;
+  }
+  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+    originalSourcePathCache.set(sourcePath, sourcePath);
+    return sourcePath;
+  }
+  const resolvedSourcePath = await findSourceFileByBasename(join4(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 = resolve4(dirname3(from), spec);
+  const candidates = [
+    basePath,
+    `${basePath}.ts`,
+    `${basePath}.js`,
+    `${basePath}.mjs`,
+    `${basePath}.cjs`,
+    `${basePath}.json`,
+    join4(basePath, "index.ts"),
+    join4(basePath, "index.js"),
+    join4(basePath, "index.mjs"),
+    join4(basePath, "index.cjs"),
+    join4(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 join4(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 = resolve4(dirname3(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(dirname3(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 = join4(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache = new Map;
+  originalSourcePathCache = new Map;
+  transpiler = new Bun.Transpiler({
+    loader: "ts",
+    target: "browser"
+  });
+});
+
+// src/core/renderIslandMarkup.ts
+var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildComponentCache, nextIslandId = () => {
+  islandSequence += 1;
+  return `island-${islandSequence}`;
+}, isRecord4 = (value) => typeof value === "object" && value !== null, isReactServerIslandComponent = (value) => typeof value === "function", isSvelteServerIslandComponent = (value) => typeof value === "function", isVueServerIslandComponent = (value) => typeof value === "function" || isRecord4(value), isAngularServerIslandComponent = (value) => typeof value === "function", resolveBuildReferencePath = (source, registryPath) => {
+  if (source.startsWith("file://"))
+    return new URL(source).pathname;
+  if (source.startsWith("."))
+    return new URL(source, registryPath).pathname;
+  return source;
+}, loadAndCompileServerBuildComponent = async (buildReferencePath) => {
+  const compiledModulePath = await compileSvelteServerModule(buildReferencePath);
+  const loadedModule = await import(compiledModulePath);
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
+}, loadServerBuildComponent = async (buildReferencePath) => {
+  const cachedBuildComponent = resolvedServerBuildComponentCache.get(buildReferencePath);
+  if (cachedBuildComponent) {
+    return cachedBuildComponent;
+  }
+  const loadPromise = loadAndCompileServerBuildComponent(buildReferencePath);
+  resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
+  return loadPromise;
+}, loadServerImportComponent = async (resolvedComponent, exportName) => {
+  const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
+  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
+  const loadedModule = await import(importTarget);
+  if (exportName && exportName !== "default" && exportName in loadedModule) {
+    return loadedModule[exportName];
+  }
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
+}, resolveIslandComponent = async (component) => {
+  const buildReference = getIslandBuildReference(component);
+  const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+  if (buildReferencePath?.endsWith(".svelte")) {
+    return loadServerBuildComponent(buildReferencePath);
+  }
+  if (buildReferencePath) {
+    return loadServerImportComponent(buildReferencePath, buildReference?.export);
+  }
+  const resolvedComponent = getIslandComponent(component);
+  if (typeof resolvedComponent !== "string") {
+    return resolvedComponent;
+  }
+  return loadServerImportComponent(resolvedComponent);
+}, resolveServerIslandComponent = async (component) => {
+  const cachedResolvedComponent = resolvedServerComponentCache.get(component);
+  if (cachedResolvedComponent) {
+    return cachedResolvedComponent;
+  }
+  const resolutionPromise = resolveIslandComponent(component);
+  resolvedServerComponentCache.set(component, resolutionPromise);
+  return resolutionPromise;
+}, resolveReactServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isReactServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved React island is not a valid React component.");
+  }
+  return resolvedComponent;
+}, resolveSvelteServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isSvelteServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Svelte island is not a valid Svelte component.");
+  }
+  return resolvedComponent;
+}, resolveVueServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isVueServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Vue island is not a valid Vue component.");
+  }
+  return resolvedComponent;
+}, resolveAngularServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isAngularServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Angular island is not a valid Angular component.");
+  }
+  return resolvedComponent;
+}, renderIslandMarkup = async (registry, props) => {
+  const result = await renderIslandResult(registry, props);
+  return `<div ${serializeIslandAttributes(result.attributes)}>${result.html}</div>`;
+}, renderIslandResult = async (registry, props) => {
+  const islandId = nextIslandId();
+  const attributes = getIslandMarkerAttributes(props);
+  if (props.framework === "react") {
+    const entry = registry.react?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "react".`);
+    }
+    const component = await resolveReactServerIslandComponent(entry);
+    const html = await renderReactIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "svelte") {
+    const entry = registry.svelte?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "svelte".`);
+    }
+    const component = await resolveSvelteServerIslandComponent(entry);
+    const html = await renderSvelteIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "vue") {
+    const entry = registry.vue?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "vue".`);
+    }
+    const component = await resolveVueServerIslandComponent(entry);
+    const html = await renderVueIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "angular") {
+    const entry = registry.angular?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "angular".`);
+    }
+    const component = await resolveAngularServerIslandComponent(entry);
+    const html = await renderAngularIslandToHtml2(component, props.props, islandId);
+    return {
+      attributes: {
+        ...getIslandMarkerAttributes(props, islandId)
+      },
+      html
+    };
+  }
+  throw new Error(`Framework "${props.framework}" is not implemented in this prototype.`);
+};
+var init_renderIslandMarkup = __esm(() => {
+  init_islandSsr();
+  init_svelteServerModule();
+  init_islandMarkupAttributes();
+  init_islands();
+  resolvedServerComponentCache = new Map;
+  resolvedServerBuildComponentCache = new Map;
+});
+
+// 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/vue/components/Image.ts
+import { computed, defineComponent, h, ref } from "vue";
+
+// src/utils/imageClient.ts
+init_constants();
+var DEFAULT_DEVICE_SIZES = IMAGE_DEFAULT_DEVICE_SIZES;
+var DEFAULT_IMAGE_SIZES = IMAGE_DEFAULT_IMAGE_SIZES;
+var DEFAULT_QUALITY = IMAGE_DEFAULT_QUALITY;
+var OPTIMIZATION_ENDPOINT = "/_absolute/image";
+var buildOptimizedUrl = (src, width, quality, basePath = OPTIMIZATION_ENDPOINT) => `${basePath}?url=${encodeURIComponent(src)}&w=${width}&q=${quality}`;
+var getAllSizes = (deviceSizes, imageSizes) => {
+  const device = deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  const image = imageSizes ?? DEFAULT_IMAGE_SIZES;
+  return [...device, ...image].sort((left, right) => left - right);
+};
+var snapToSize = (target, sizes) => {
+  for (const size of sizes) {
+    if (size >= target)
+      return size;
+  }
+  return sizes[sizes.length - 1] ?? target;
+};
+var generateBlurSvg = (base64Thumbnail) => {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><filter id="b" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="20"/><feColorMatrix values="1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1"/></filter><image filter="url(#b)" x="0" y="0" width="100%" height="100%" href="${base64Thumbnail}"/></svg>`;
+  const encoded = encodeURIComponent(svg);
+  return `url("data:image/svg+xml,${encoded}")`;
+};
+var generateSrcSet = (src, width, sizes, deviceSizes, imageSizes) => {
+  const quality = DEFAULT_QUALITY;
+  if (sizes) {
+    const allSizes = getAllSizes(deviceSizes, imageSizes);
+    return allSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality)} ${sizeWidth}w`).join(", ");
+  }
+  if (width) {
+    const allSizes = getAllSizes(deviceSizes, imageSizes);
+    const w1x = snapToSize(width, allSizes);
+    const w2x = snapToSize(width * 2, allSizes);
+    return `${buildOptimizedUrl(src, w1x, quality)} 1x, ${buildOptimizedUrl(src, w2x, quality)} 2x`;
+  }
+  const devSizes = deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  return devSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality)} ${sizeWidth}w`).join(", ");
+};
+
+// src/vue/components/Image.ts
+var fillWrapperStyle = {
+  display: "block",
+  height: "100%",
+  overflow: "hidden",
+  position: "relative",
+  width: "100%"
+};
+var Image = defineComponent({
+  name: "AbsoluteImage",
+  props: {
+    alt: { required: true, type: String },
+    blurDataURL: { default: undefined, type: String },
+    className: { default: undefined, type: String },
+    crossOrigin: { default: undefined, type: String },
+    fetchPriority: { default: undefined, type: String },
+    fill: { default: false, type: Boolean },
+    height: { default: undefined, type: Number },
+    loader: { default: undefined, type: Function },
+    loading: { default: "lazy", type: String },
+    onError: { default: undefined, type: Function },
+    onLoad: { default: undefined, type: Function },
+    overrideSrc: { default: undefined, type: String },
+    placeholder: { default: undefined, type: String },
+    priority: { default: false, type: Boolean },
+    quality: { default: DEFAULT_QUALITY, type: Number },
+    referrerPolicy: { default: undefined, type: String },
+    sizes: { default: undefined, type: String },
+    src: { required: true, type: String },
+    style: { default: undefined, type: Object },
+    unoptimized: { default: false, type: Boolean },
+    width: { default: undefined, type: Number }
+  },
+  setup(props) {
+    const blurRemoved = ref(false);
+    const resolvedSrc = computed(() => {
+      if (props.overrideSrc)
+        return props.overrideSrc;
+      if (props.unoptimized)
+        return props.src;
+      if (props.loader) {
+        return props.loader({
+          quality: props.quality ?? DEFAULT_QUALITY,
+          src: props.src,
+          width: props.width ?? 0
+        });
+      }
+      if (!props.width) {
+        return buildOptimizedUrl(props.src, 0, props.quality ?? DEFAULT_QUALITY);
+      }
+      return buildOptimizedUrl(props.src, props.width, props.quality ?? DEFAULT_QUALITY);
+    });
+    const srcSet = computed(() => props.unoptimized ? undefined : generateSrcSet(props.src, props.width, props.sizes));
+    const resolvedSizes = computed(() => props.sizes ?? (props.fill ? "100vw" : undefined));
+    const resolvedLoading = computed(() => props.priority ? "eager" : props.loading ?? "lazy");
+    const resolvedFetchPriority = computed(() => props.priority ? "high" : props.fetchPriority);
+    const hasBlur = computed(() => props.placeholder === "blur" || typeof props.placeholder === "string" && props.placeholder !== "empty" && props.placeholder.startsWith("data:"));
+    const blurBackground = computed(() => {
+      if (!hasBlur.value || blurRemoved.value)
+        return;
+      if (typeof props.placeholder === "string" && props.placeholder !== "blur" && props.placeholder.startsWith("data:")) {
+        return generateBlurSvg(props.placeholder);
+      }
+      if (props.blurDataURL)
+        return generateBlurSvg(props.blurDataURL);
+      return;
+    });
+    const imgStyle = computed(() => {
+      const base = {
+        ...props.style ?? {},
+        color: "transparent"
+      };
+      if (blurBackground.value) {
+        base.backgroundImage = blurBackground.value;
+        base.backgroundPosition = "center";
+        base.backgroundRepeat = "no-repeat";
+        base.backgroundSize = "cover";
+      }
+      if (props.fill) {
+        base.height = "100%";
+        base.inset = "0";
+        base.objectFit = "cover";
+        base.position = "absolute";
+        base.width = "100%";
+      }
+      return base;
+    });
+    const handleLoad = (event) => {
+      blurRemoved.value = true;
+      props.onLoad?.(event);
+    };
+    const handleError = (event) => {
+      props.onError?.(event);
+    };
+    return () => {
+      const imgNode = h("img", {
+        alt: props.alt,
+        class: props.className,
+        crossorigin: props.crossOrigin,
+        decoding: "async",
+        fetchpriority: resolvedFetchPriority.value,
+        height: props.fill ? undefined : props.height,
+        loading: resolvedLoading.value,
+        onError: handleError,
+        onLoad: handleLoad,
+        referrerpolicy: props.referrerPolicy,
+        sizes: resolvedSizes.value,
+        src: resolvedSrc.value,
+        srcset: srcSet.value,
+        style: imgStyle.value,
+        width: props.fill ? undefined : props.width
+      });
+      return props.fill ? h("span", { style: fillWrapperStyle }, [imgNode]) : imgNode;
+    };
+  }
+});
+// src/vue/components/SuspenseSlot.ts
 import {
-  getIslandMarkerAttributes
-} from "../chunk-2f21eenc.js";
-import"../chunk-fygx2ymm.js";
-import"../chunk-8kcfffry.js";
-import"../chunk-3yjzpcne.js";
-import"../chunk-bmgqm774.js";
+  cloneVNode,
+  defineComponent as defineComponent2,
+  h as h2,
+  isVNode,
+  onMounted,
+  onBeforeUnmount,
+  ref as ref2,
+  useSSRContext
+} from "vue";
+var renderVueNodesToHtml = async (nodes) => {
+  const { createSSRApp, h: createVNode } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const app = createSSRApp({
+    render: () => createVNode("div", undefined, nodes ?? undefined)
+  });
+  const html = await renderToString(app);
+  return html.replace(/^<div>|<\/div>$/g, "");
+};
+var hasFrameworkSlots = (defaultSlot, fallbackSlot, errorSlot, promise) => defaultSlot !== undefined || fallbackSlot !== undefined || errorSlot !== undefined || promise !== undefined;
+var allowMismatchOnSlotNodes = (nodes) => {
+  if (Array.isArray(nodes)) {
+    return nodes.map((node) => allowMismatchOnSlotNodes(node));
+  }
+  if (isVNode(nodes)) {
+    return cloneVNode(nodes, {
+      "data-allow-mismatch": ""
+    });
+  }
+  return nodes;
+};
+var resolveSuspenseValue = async (resolve, promise) => {
+  if (resolve !== undefined) {
+    return resolve();
+  }
+  if (promise !== undefined) {
+    return promise;
+  }
+  return;
+};
+var isObjectRecord3 = (value) => Boolean(value) && typeof value === "object";
+var isVueSuspensePayload = (payload) => {
+  if (!isObjectRecord3(payload)) {
+    return false;
+  }
+  return payload.kind === "vue-suspense";
+};
+var hasEventDetailId = (event, id) => {
+  if (!(event instanceof CustomEvent)) {
+    return false;
+  }
+  const { detail } = event;
+  if (!detail || typeof detail !== "object") {
+    return false;
+  }
+  return detail.id === id;
+};
+var toLegacySuspenseSlotRegistration = (props) => {
+  if (!props.resolve) {
+    return null;
+  }
+  return {
+    errorHtml: props.errorHtml,
+    fallbackHtml: props.fallbackHtml,
+    id: props.id,
+    timeoutMs: props.timeoutMs,
+    resolve: async () => {
+      const resolved = await props.resolve?.();
+      return typeof resolved === "string" ? resolved : "";
+    }
+  };
+};
+var registerLegacySuspenseSlot = (props) => {
+  registerStreamingSlot({
+    errorHtml: props.errorHtml,
+    fallbackHtml: props.fallbackHtml,
+    id: props.id,
+    resolve: props.resolve,
+    timeoutMs: props.timeoutMs
+  });
+};
+var resolveStreamingSuspenseSlot = async (props, slots) => {
+  try {
+    const value = await resolveSuspenseValue(props.resolve, props.promise);
+    const nodes = allowMismatchOnSlotNodes(slots.default?.({ value }) ?? []);
+    const html = await renderVueNodesToHtml(nodes);
+    return {
+      html,
+      kind: "vue-suspense",
+      value
+    };
+  } catch (error) {
+    const errorNodes = slots.error?.({ error });
+    if (errorNodes !== undefined)
+      return renderVueNodesToHtml(allowMismatchOnSlotNodes(errorNodes));
+    if (typeof props.errorHtml === "string")
+      return props.errorHtml;
+    throw error;
+  }
+};
+var registerSuspenseSlotForSsr = (props, slots, usesFrameworkSlots) => {
+  if (!isStreamingSlotCollectionActive()) {
+    warnMissingStreamingSlotCollector("SuspenseSlot");
+  }
+  const legacyRegistration = toLegacySuspenseSlotRegistration(props);
+  if (!usesFrameworkSlots && legacyRegistration) {
+    registerLegacySuspenseSlot(legacyRegistration);
+    return;
+  }
+  registerStreamingSlot({
+    id: props.id,
+    timeoutMs: props.timeoutMs,
+    resolve: () => resolveStreamingSuspenseSlot(props, slots)
+  });
+};
+var applySuspensePayload = (payload, state) => {
+  state.hasError.value = payload.state === "error";
+  state.resolvedValue.value = payload.value;
+  state.isResolved.value = payload.state !== "error";
+};
+var SuspenseSlot = defineComponent2({
+  name: "AbsoluteSuspenseSlot",
+  props: {
+    className: { default: undefined, type: String },
+    errorHtml: { default: undefined, type: String },
+    fallbackHtml: { default: "", type: String },
+    id: { required: true, type: String },
+    promise: {
+      default: undefined,
+      type: Object
+    },
+    resolve: {
+      default: undefined,
+      type: Function
+    },
+    timeoutMs: { default: undefined, type: Number }
+  },
+  setup(props, { slots }) {
+    const readPatchedDomState = () => {
+      if (typeof document === "undefined")
+        return false;
+      const slotNode = document.getElementById(props.id);
+      if (!slotNode)
+        return false;
+      return slotNode.getAttribute("data-absolute-slot-state") === "resolved";
+    };
+    const isResolved = ref2(false);
+    const resolvedValue = ref2(undefined);
+    const hasError = ref2(false);
+    const hasPatchedDom = ref2(readPatchedDomState());
+    const usesFrameworkSlots = hasFrameworkSlots(slots.default, slots.fallback, slots.error, props.promise);
+    const isSsrRender = useSSRContext() !== undefined;
+    if (isSsrRender) {
+      registerSuspenseSlotForSsr(props, slots, usesFrameworkSlots);
+    }
+    if (typeof window !== "undefined" && usesFrameworkSlots) {
+      const consumers = window.__ABS_SLOT_CONSUMERS__ = window.__ABS_SLOT_CONSUMERS__ ?? {};
+      let runtimeReady = false;
+      consumers[props.id] = (payload) => {
+        if (!runtimeReady)
+          return false;
+        if (!isVueSuspensePayload(payload)) {
+          return false;
+        }
+        applySuspensePayload(payload, {
+          hasError,
+          isResolved,
+          resolvedValue
+        });
+        return true;
+      };
+      const handlePatchedDom = (event) => {
+        if (hasEventDetailId(event, props.id)) {
+          hasPatchedDom.value = true;
+        }
+      };
+      onMounted(() => {
+        hasPatchedDom.value = readPatchedDomState();
+        window.addEventListener("absolutejs:slot-patch", handlePatchedDom);
+        runtimeReady = true;
+        window.__ABS_SLOT_FLUSH__?.();
+      });
+      onBeforeUnmount(() => {
+        window.removeEventListener("absolutejs:slot-patch", handlePatchedDom);
+        delete window.__ABS_SLOT_CONSUMERS__?.[props.id];
+      });
+    }
+    const resolveSlotChildren = () => {
+      if (hasPatchedDom.value) {
+        return;
+      }
+      if (hasError.value) {
+        return allowMismatchOnSlotNodes(slots.error?.({ error: undefined }) ?? slots.fallback?.() ?? undefined) ?? undefined;
+      }
+      if (isResolved.value) {
+        return allowMismatchOnSlotNodes(slots.default?.({ value: resolvedValue.value }) ?? undefined) ?? undefined;
+      }
+      return allowMismatchOnSlotNodes(slots.fallback?.() ?? undefined);
+    };
+    return () => {
+      if (!usesFrameworkSlots) {
+        return h2("div", {
+          class: props.className,
+          "data-absolute-slot": "true",
+          id: props.id,
+          innerHTML: props.fallbackHtml
+        });
+      }
+      return h2("div", {
+        class: props.className,
+        "data-absolute-slot": "true",
+        "data-allow-mismatch": "",
+        id: props.id
+      }, resolveSlotChildren() ?? undefined);
+    };
+  }
+});
+// src/vue/components/StreamSlot.ts
+import { defineComponent as defineComponent3, h as h3, useSSRContext as useSSRContext2 } from "vue";
+var StreamSlot = defineComponent3({
+  name: "AbsoluteStreamSlot",
+  props: {
+    className: { default: undefined, type: String },
+    errorHtml: { default: undefined, type: String },
+    fallbackHtml: { default: "", type: String },
+    id: { required: true, type: String },
+    resolve: {
+      required: true,
+      type: Function
+    },
+    timeoutMs: { default: undefined, type: Number }
+  },
+  setup(props) {
+    if (useSSRContext2() !== undefined) {
+      registerStreamSlotForSsr(props);
+    }
+    return () => h3("div", {
+      class: props.className,
+      "data-absolute-slot": "true",
+      id: props.id,
+      innerHTML: props.fallbackHtml
+    });
+  }
+});
+var registerStreamSlotForSsr = (props) => {
+  if (!isStreamingSlotCollectionActive()) {
+    warnMissingStreamingSlotCollector("StreamSlot");
+    return;
+  }
+  registerStreamingSlot({
+    errorHtml: props.errorHtml,
+    fallbackHtml: props.fallbackHtml,
+    id: props.id,
+    resolve: props.resolve,
+    timeoutMs: props.timeoutMs
+  });
+};
+// src/vue/pageHandler.ts
+init_constants();
+import { readdir } from "fs/promises";
+import { basename as basename2, dirname } from "path";
+
+// src/core/islandPageContext.ts
+init_constants();
+var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
+var ISLAND_MARKER = 'data-island="true"';
+var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
+var ISLAND_STATE_MARKER = "__ABS_ISLAND_STATE__";
+var CLOSING_HEAD_TAG = "</head>";
+var buildIslandsHeadMarkup = (manifest) => {
+  const manifestScript = `<script>window.__ABSOLUTE_MANIFEST__ = ${JSON.stringify(manifest)}</script>`;
+  const islandStateScript = `<script>window.__ABS_ISLAND_STATE__ = ${JSON.stringify(globalThis.__ABS_ISLAND_STATE__ ?? {})}</script>`;
+  const bootstrapPath = manifest[BOOTSTRAP_MANIFEST_KEY];
+  const bootstrapScript = bootstrapPath ? `<script type="module" src="${bootstrapPath}"></script>` : "";
+  return `${manifestScript}${islandStateScript}${bootstrapScript}`;
+};
+var injectHeadMarkup = (html, markup) => {
+  const closingHeadIndex = html.indexOf("</head>");
+  if (closingHeadIndex >= 0) {
+    return `${html.slice(0, closingHeadIndex)}${markup}${html.slice(closingHeadIndex)}`;
+  }
+  const openingBodyIndex = html.indexOf("<body");
+  if (openingBodyIndex >= 0) {
+    const bodyStart = html.indexOf(">", openingBodyIndex);
+    if (bodyStart >= 0) {
+      return `${html.slice(0, openingBodyIndex)}<head>${markup}</head>${html.slice(openingBodyIndex)}`;
+    }
+  }
+  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
+};
+var streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
+var flushSafePendingText = (controller, encoder, pending, lookbehind) => {
+  if (pending.length <= lookbehind) {
+    return pending;
+  }
+  const safeText = pending.slice(0, pending.length - lookbehind);
+  controller.enqueue(encoder.encode(safeText));
+  return pending.slice(-lookbehind);
+};
+var updateInjectedState = (consumed, injected, pending) => {
+  if (consumed.done) {
+    return { done: true, injected, pending };
+  }
+  return {
+    done: false,
+    injected: consumed.injected,
+    pending: consumed.pending
+  };
+};
+var readStreamChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  if (done || !value) {
+    return { done, value: undefined };
+  }
+  return { done, value };
+};
+var pipeStreamWithHeadInjection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = CLOSING_HEAD_TAG.length - 1;
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex >= 0) {
+      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishHeadInjectionStream = (controller, pending, injected) => {
+    let finalPending = pending + decoder.decode();
+    if (!injected) {
+      finalPending = injectHeadMarkup(finalPending, markup);
+    }
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeHeadChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runHeadInjectionLoop = async (controller, reader) => {
+    const consumeNextHeadChunk = async (injected, pending) => {
+      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextHeadChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextHeadChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
+        finishHeadInjectionStream(controller, pending, injected);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const markerIndex = pending.indexOf(ISLAND_MARKER);
+    if (markerIndex >= 0) {
+      const tagStart = pending.lastIndexOf("<", markerIndex);
+      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
+      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishIslandMarkerStream = (controller, pending) => {
+    const finalPending = pending + decoder.decode();
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeIslandChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runIslandMarkerLoop = async (controller, reader) => {
+    const consumeNextIslandChunk = async (injected, pending) => {
+      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextIslandChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { pending } = await runIslandMarkerLoop(controller, reader);
+        finishIslandMarkerStream(controller, pending);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var htmlContainsIslands = (html) => html.includes(ISLAND_MARKER);
+var injectIslandPageContext = (html, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  const hasIslands = options?.hasIslands ?? htmlContainsIslands(html);
+  if (!manifest || !hasIslands) {
+    return html;
+  }
+  if (html.includes(MANIFEST_MARKER) || html.includes(ISLAND_STATE_MARKER)) {
+    return html;
+  }
+  return injectHeadMarkup(html, buildIslandsHeadMarkup(manifest));
+};
+var injectIslandPageContextStream = (stream, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  if (!manifest)
+    return stream;
+  const markup = buildIslandsHeadMarkup(manifest);
+  if (options?.hasIslands === true) {
+    return pipeStreamWithHeadInjection(stream, markup);
+  }
+  if (options?.hasIslands === false) {
+    return stream;
+  }
+  return pipeStreamWithIslandMarkerDetection(stream, markup);
+};
+var setCurrentIslandManifest = (manifest) => {
+  globalThis.__absoluteManifest = manifest;
+};
+
+// src/vue/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 isObjectRecord5 = (value) => Boolean(value) && typeof value === "object";
+var isAsyncLocalStorage3 = (value) => isObjectRecord5(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/vue/pageHandler.ts
+init_ssrCache();
+
+// src/utils/ssrErrorPage.ts
+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/resolveConvention.ts
+import { basename } 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 = basename(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 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 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 setConventions = (map) => {
+  Reflect.set(globalThis, CONVENTIONS_KEY, map);
+};
+var isDev = () => true;
+var buildErrorProps = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = isDev() && error instanceof Error ? error.stack : undefined;
+  return { error: { message, stack } };
+};
+var renderReactError = async (conventionPath, errorProps) => {
+  const { createElement } = await import("react");
+  const { renderToReadableStream } = await import("react-dom/server");
+  const mod = await import(conventionPath);
+  const [firstKey] = Object.keys(mod);
+  const ErrorComponent = mod.default ?? (firstKey ? mod[firstKey] : undefined);
+  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;
+  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: h4 } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const ErrorComponent = mod.default;
+  const app = createSSRApp({
+    render: () => h4(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 renderError = mod.default ?? mod.renderError;
+  if (typeof renderError !== "function")
+    return null;
+  const html = renderError(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 ERROR_RENDERERS = {
+  angular: renderAngularError,
+  react: renderReactError,
+  svelte: renderSvelteError,
+  vue: renderVueError
+};
+var renderConventionError = async (framework, pageName, 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 errorProps = buildErrorProps(error);
+  const renderer = ERROR_RENDERERS[framework];
+  if (!renderer)
+    return null;
+  try {
+    return await renderer(conventionPath, errorProps);
+  } catch (renderError) {
+    logConventionRenderError(framework, "error", renderError);
+  }
+  return null;
+};
+var renderReactNotFound = async (conventionPath) => {
+  const { createElement } = await import("react");
+  const { renderToReadableStream } = await import("react-dom/server");
+  const mod = await import(conventionPath);
+  const [nfKey] = Object.keys(mod);
+  const NotFoundComponent = mod.default ?? (nfKey ? mod[nfKey] : undefined);
+  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;
+  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: h4 } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const NotFoundComponent = mod.default;
+  const app = createSSRApp({
+    render: () => h4(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 renderNotFound = mod.default ?? mod.renderNotFound;
+  if (typeof renderNotFound !== "function")
+    return null;
+  const html = renderNotFound();
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+};
+var NOT_FOUND_RENDERERS = {
+  angular: renderAngularNotFound,
+  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"
+];
+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/vue/pageHandler.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isGenericVueComponent = (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 resolveCurrentGeneratedVueModulePath = async (pagePath) => {
+  const pageDirectory = dirname(pagePath);
+  const expectedPrefix = `${basename2(pagePath, ".js").split(".")[0]}.`;
+  try {
+    const pageEntries = await readdir(pageDirectory, {
+      withFileTypes: true
+    });
+    const matchingEntry = pageEntries.find((entry) => entry.isFile() && entry.name.endsWith(".js") && (entry.name === `${expectedPrefix.slice(0, EXCLUDE_LAST_OFFSET)}.js` || entry.name.startsWith(expectedPrefix)));
+    if (!matchingEntry) {
+      return pagePath;
+    }
+    return `${pageDirectory}/${matchingEntry.name}`;
+  } catch {
+    return pagePath;
+  }
+};
+var buildDirtyResponse = (headTag, indexPath, maybeProps) => {
+  const propsScript = `window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})};`;
+  const dirtyFlag = "window.__SSR_DIRTY__=true;";
+  const html = `<!DOCTYPE html><html>${headTag}<body><div id="root"></div>` + `<script>${propsScript}${dirtyFlag}</script>` + `<script type="module" src="${indexPath}"></script>` + `</body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" }
+  });
+};
+var primeVueStream = async (stream) => {
+  const reader = stream.getReader();
+  const firstChunk = await reader.read();
+  return { firstChunk, reader };
+};
+var handleVuePageRequest = async (input) => {
+  const passedPageComponent = input.Page;
+  const resolvedHeadTag = input.headTag ?? "<head></head>";
+  const resolvedIndexPath = input.indexPath;
+  const resolvedOptions = input;
+  const resolvedPagePath = input.pagePath;
+  const maybeProps = input.props;
+  if (isSsrCacheDirty("vue")) {
+    return buildDirtyResponse(resolvedHeadTag, resolvedIndexPath, maybeProps);
+  }
+  try {
+    const handlerCallsite = resolvedOptions?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
+    const renderPageResponse = async () => {
+      const resolvePageComponent = async () => {
+        if (isGenericVueComponent(passedPageComponent)) {
+          return {
+            component: passedPageComponent,
+            hasIslands: readHasIslands(passedPageComponent)
+          };
+        }
+        const generatedPagePath = await resolveCurrentGeneratedVueModulePath(resolvedPagePath);
+        const importedPageModule = await import(generatedPagePath);
+        const importedPageComponent = readDefaultExport(importedPageModule) ?? importedPageModule;
+        if (!isGenericVueComponent(importedPageComponent)) {
+          throw new Error(`Invalid Vue page module: ${generatedPagePath}`);
+        }
+        return {
+          component: importedPageComponent,
+          hasIslands: readHasIslands(importedPageModule)
+        };
+      };
+      const resolvedPage = await resolvePageComponent();
+      const { createSSRApp, h: h4 } = await import("vue");
+      const { renderToWebStream } = await import("vue/server-renderer");
+      const app = createSSRApp({
+        render: () => h4(resolvedPage.component, maybeProps ?? null)
+      });
+      const bodyStream = renderToWebStream(app);
+      const { firstChunk, reader } = await primeVueStream(bodyStream);
+      const head = `<!DOCTYPE html><html>${resolvedHeadTag}<body><div id="root">`;
+      const tail = `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${resolvedIndexPath}"></script></body></html>`;
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(head);
+          if (!firstChunk.done) {
+            controller.enqueue(firstChunk.value);
+          }
+          if (firstChunk.done) {
+            controller.enqueue(tail);
+            controller.close();
+            return;
+          }
+          const pumpLoop = () => {
+            reader.read().then(({ done, value }) => done ? (controller.enqueue(tail), controller.close()) : (controller.enqueue(value), pumpLoop())).catch((err) => controller.error(err));
+          };
+          pumpLoop();
+        }
+      });
+      const htmlStream = injectIslandPageContextStream(stream, {
+        hasIslands: resolvedPage.hasIslands
+      });
+      return new Response(htmlStream, {
+        headers: { "Content-Type": "text/html" }
+      });
+    };
+    return await runWithStreamingSlotWarningScope(() => resolvedOptions?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, resolvedOptions) : renderPageResponse(), { handlerCallsite });
+  } catch (error) {
+    console.error("[SSR] Vue render error:", error);
+    const pageName = derivePageName(resolvedPagePath);
+    const conventionResponse = await renderConventionError("vue", pageName, error);
+    if (conventionResponse)
+      return conventionResponse;
+    return new Response(ssrErrorPage("vue", error), {
+      headers: { "Content-Type": "text/html" },
+      status: 500
+    });
+  }
+};
 // src/vue/Island.ts
-import { defineComponent, h, onServerPrefetch } from "vue";
-var defineRuntimeIslandComponent = (setup) => defineComponent({
+import { defineComponent as defineComponent4, h as h4, onServerPrefetch } from "vue";
+
+// src/client/preserveIslandMarkup.ts
+init_islandMarkupAttributes();
+var getClaimMap = () => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  window.__ABS_CLAIMED_ISLAND_MARKUP__ ??= new Map;
+  return window.__ABS_CLAIMED_ISLAND_MARKUP__;
+};
+var getSnapshotMap = () => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  window.__ABS_SERVER_ISLAND_HTML__ ??= new Map;
+  return window.__ABS_SERVER_ISLAND_HTML__;
+};
+var getIslandSignature = (props) => {
+  const attributes = getIslandMarkerAttributes(props);
+  return [
+    attributes["data-component"],
+    attributes["data-framework"],
+    attributes["data-hydrate"],
+    attributes["data-props"]
+  ].join("::");
+};
+var isMatchingIslandElement = (element, props) => {
+  if (!(element instanceof HTMLElement)) {
+    return false;
+  }
+  const attributes = getIslandMarkerAttributes(props);
+  return element.dataset.island === "true" && element.dataset.component === attributes["data-component"] && element.dataset.framework === attributes["data-framework"] && (element.dataset.hydrate ?? "load") === attributes["data-hydrate"] && (element.dataset.props ?? "{}") === attributes["data-props"];
+};
+var snapshotIslandElement = (element, snapshotMap) => {
+  const signature = [
+    element.dataset.component,
+    element.dataset.framework,
+    element.dataset.hydrate ?? "load",
+    element.dataset.props ?? "{}"
+  ].join("::");
+  const existing = snapshotMap.get(signature) ?? [];
+  const attributes = Object.fromEntries(element.getAttributeNames().map((name) => [name, element.getAttribute(name) ?? ""]));
+  existing.push({
+    attributes,
+    innerHTML: element.innerHTML
+  });
+  snapshotMap.set(signature, existing);
+};
+var initializeIslandMarkupSnapshot = () => {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const snapshotMap = getSnapshotMap();
+  if (!snapshotMap || snapshotMap.size > 0) {
+    return;
+  }
+  const elements = Array.from(document.querySelectorAll('[data-island="true"]'));
+  for (const element of elements) {
+    snapshotIslandElement(element, snapshotMap);
+  }
+};
+var preserveIslandMarkup = (props) => {
+  if (typeof document === "undefined") {
+    return {
+      attributes: getIslandMarkerAttributes(props),
+      innerHTML: ""
+    };
+  }
+  const claimMap = getClaimMap();
+  const snapshotMap = getSnapshotMap();
+  const signature = getIslandSignature(props);
+  const claimedCount = claimMap?.get(signature) ?? 0;
+  const snapshotCandidate = snapshotMap?.get(signature)?.[claimedCount];
+  const candidates = Array.from(document.querySelectorAll('[data-island="true"]')).filter((element) => isMatchingIslandElement(element, props));
+  const candidate = candidates[claimedCount];
+  if (claimMap) {
+    claimMap.set(signature, claimedCount + 1);
+  }
+  return {
+    attributes: snapshotCandidate?.attributes ?? getIslandMarkerAttributes(props),
+    innerHTML: snapshotCandidate?.innerHTML ?? candidate?.innerHTML ?? ""
+  };
+};
+
+// src/vue/Island.ts
+init_islandMarkupAttributes();
+init_renderIslandMarkup();
+var defineRuntimeIslandComponent = (setup) => defineComponent4({
   name: "AbsoluteIsland",
   props: {
     component: {
@@ -80,7 +4100,7 @@ var Island = defineRuntimeIslandComponent((props) => {
   });
   return () => {
     const preserved = isBrowser ? preserveIslandMarkup(props) : null;
-    return h("div", {
+    return h4("div", {
       ...preserved?.attributes ?? markerAttributes,
       "data-allow-mismatch": "",
       innerHTML: isBrowser ? preserved?.innerHTML : html
@@ -88,8 +4108,10 @@ var Island = defineRuntimeIslandComponent((props) => {
   };
 });
 // src/vue/createIsland.ts
-import { defineComponent as defineComponent2, h as h2, onServerPrefetch as onServerPrefetch2 } from "vue";
-var defineRuntimeIslandComponent2 = (setup) => defineComponent2({
+init_islandMarkupAttributes();
+init_renderIslandMarkup();
+import { defineComponent as defineComponent5, h as h5, onServerPrefetch as onServerPrefetch2 } from "vue";
+var defineRuntimeIslandComponent2 = (setup) => defineComponent5({
   name: "AbsoluteIsland",
   props: {
     component: {
@@ -119,12 +4141,150 @@ var createTypedIsland = (registry) => defineRuntimeIslandComponent2((props) => {
     const result = await renderIslandResult(registry, props);
     ({ attributes: markerAttributes, html } = result);
   });
-  return () => h2("div", {
+  return () => h5("div", {
     ...markerAttributes,
     "data-allow-mismatch": "",
     innerHTML: isBrowser ? undefined : html
   });
 });
+// src/vue/useIslandStore.ts
+import { customRef, onBeforeUnmount as onBeforeUnmount2 } from "vue";
+
+// node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set;
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+// node_modules/zustand/esm/middleware.mjs
+function combine(initialState, create) {
+  return (...args) => Object.assign({}, initialState, create(...args));
+}
+
+// src/client/islandStore.ts
+var getIslandStoreSnapshot = () => {
+  globalThis.__ABS_ISLAND_STATE__ ??= {};
+  return globalThis.__ABS_ISLAND_STATE__;
+};
+var getIslandStores = () => {
+  globalThis.__ABS_ISLAND_STORES__ ??= new Map;
+  return globalThis.__ABS_ISLAND_STORES__;
+};
+var isSerializableValue = (value) => typeof value !== "function" && value !== undefined;
+var toSerializableState = (state) => Object.fromEntries(Object.entries(state).filter(([, value]) => isSerializableValue(value)));
+var applySnapshot = (store, snapshot) => {
+  if (!snapshot) {
+    return;
+  }
+  store.setState({
+    ...store.getState(),
+    ...snapshot
+  });
+};
+var getPeerStores = (storeInstances, ownerStore) => [...storeInstances].filter((peer) => peer.store !== ownerStore);
+var syncIslandSnapshot = (storeId, state, storeInstances, ownerStore) => {
+  const nextSnapshot = toSerializableState(state);
+  getIslandStoreSnapshot()[storeId] = nextSnapshot;
+  for (const peerStore of getPeerStores(storeInstances, ownerStore)) {
+    peerStore.applyExternalSnapshot(nextSnapshot);
+  }
+};
+var createIslandStore = (storeId, initialState, createState) => {
+  const store = createStore(combine(initialState, createState));
+  const stores = getIslandStores();
+  const storeInstances = stores.get(storeId) ?? new Set;
+  const initialSnapshot = getIslandStoreSnapshot()[storeId];
+  applySnapshot(store, initialSnapshot);
+  let isApplyingExternalSnapshot = false;
+  const applyExternalSnapshot = (snapshot) => {
+    isApplyingExternalSnapshot = true;
+    applySnapshot(store, snapshot);
+  };
+  storeInstances.add({
+    applyExternalSnapshot,
+    store
+  });
+  stores.set(storeId, storeInstances);
+  syncIslandSnapshot(storeId, store.getState(), storeInstances, store);
+  store.subscribe((state) => {
+    if (isApplyingExternalSnapshot) {
+      isApplyingExternalSnapshot = false;
+      return;
+    }
+    syncIslandSnapshot(storeId, state, storeInstances, store);
+  });
+  return store;
+};
+var getIslandStoreServerSnapshot = (store, selector) => selector(store.getInitialState());
+var applySnapshotToStoreInstances = (storeId, instances, snapshot) => {
+  for (const instance of instances) {
+    instance.applyExternalSnapshot(snapshot[storeId] ?? {});
+  }
+};
+var initializeIslandStores = (state) => {
+  const currentSnapshot = getIslandStoreSnapshot();
+  const nextSnapshot = {
+    ...state,
+    ...currentSnapshot
+  };
+  globalThis.__ABS_ISLAND_STATE__ = nextSnapshot;
+  for (const [storeId, store] of getIslandStores()) {
+    applySnapshotToStoreInstances(storeId, store, nextSnapshot);
+  }
+};
+var readIslandStore = (store, selector) => selector(store.getState());
+var subscribeIslandStore = (store, selector, listener) => {
+  let currentSelection = selector(store.getState());
+  return store.subscribe((state) => {
+    const nextSelection = selector(state);
+    if (Object.is(nextSelection, currentSelection)) {
+      return;
+    }
+    currentSelection = nextSelection;
+    listener(nextSelection);
+  });
+};
+
+// src/vue/useIslandStore.ts
+var useIslandStore = (store, selector) => {
+  let current = readIslandStore(store, selector);
+  let unsubscribe;
+  const state = customRef((track, trigger) => {
+    unsubscribe = subscribeIslandStore(store, selector, (value) => {
+      current = value;
+      trigger();
+    });
+    return {
+      get() {
+        track();
+        return current;
+      },
+      set() {}
+    };
+  });
+  onBeforeUnmount2(() => {
+    unsubscribe?.();
+  });
+  return state;
+};
 export {
   useIslandStore,
   handleVuePageRequest,
@@ -135,5 +4295,5 @@ export {
   Image
 };
 
-//# debugId=EAA0EECCB6DF7CBE64756E2164756E21
+//# debugId=3DBC449F9850B08A64756E2164756E21
 //# sourceMappingURL=index.js.map