@absolutejs/absolute 0.19.0-beta.783 → 0.19.0-beta.784

package/dist/chunk-qh75agse.js

@@ -0,0 +1,95 @@
+// @bun
+// src/constants.ts
+var ANGULAR_INIT_TIMEOUT_MS = 500;
+var ANSI_ESCAPE_CODE = 27;
+var ANSI_ESCAPE_LENGTH = 3;
+var ASCII_SPACE = 32;
+var BASE_36_RADIX = 36;
+var BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet";
+var BODY_SLICE_LENGTH = 2000;
+var BYTES_PER_KILOBYTE = 1024;
+var CLI_ARGS_OFFSET = 3;
+var CSS_ERROR_RESOLVE_DELAY_MS = 50;
+var CSS_MAX_CHECK_ATTEMPTS = 10;
+var CSS_MAX_PARSE_TIMEOUT_MS = 500;
+var CSS_SHEET_READY_TIMEOUT_MS = 100;
+var DEFAULT_CHUNK_SIZE = 16384;
+var DEFAULT_DEBOUNCE_MS = 15;
+var DEFAULT_PORT = 3000;
+var DEV_SERVER_RESTART_DEBOUNCE_MS = 100;
+var DOM_UPDATE_DELAY_MS = 50;
+var FILE_PROTOCOL_PREFIX_LENGTH = 7;
+var FOCUS_ID_PREFIX_LENGTH = 3;
+var FOCUS_IDX_PREFIX_LENGTH = 4;
+var FOCUS_NAME_PREFIX_LENGTH = 5;
+var HMR_UPDATE_TIMEOUT_MS = 2000;
+var HOOK_SIGNATURE_LENGTH = 12;
+var EXCLUDE_LAST_OFFSET = -1;
+var HTTP_STATUS_OK = 200;
+var HTTP_STATUS_BAD_REQUEST = 400;
+var HTTP_STATUS_NOT_FOUND = 404;
+var HOURS_IN_DAY = 24;
+var HOURS_IN_HALF_DAY = 12;
+var IMAGE_DEFAULT_DEVICE_SIZES = [
+  640,
+  750,
+  828,
+  1080,
+  1200,
+  1920,
+  2048,
+  3840
+];
+var IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+var IMAGE_DEFAULT_QUALITY = 75;
+var IMAGE_GLOB_SUFFIX_LENGTH = 2;
+var MAX_ERROR_LENGTH = 200;
+var MAX_RECONNECT_ATTEMPTS = 60;
+var MILLISECONDS_IN_A_SECOND = 1000;
+var MINUTES_IN_AN_HOUR = 60;
+var SECONDS_IN_A_MINUTE = 60;
+var MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+var MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+var OVERLAY_FADE_DURATION_MS = 150;
+var PING_INTERVAL_MS = 30000;
+var RAF_BATCH_COUNT = 3;
+var RANDOM_ID_END_INDEX = 11;
+var REBUILD_BATCH_DELAY_MS = 10;
+var REBUILD_RELOAD_DELAY_MS = 200;
+var RECONNECT_INITIAL_DELAY_MS = 500;
+var RECONNECT_POLL_INTERVAL_MS = 300;
+var REACT_STREAM_SLOT_FAST_DELAY_MS = 5;
+var REACT_STREAM_SLOT_SLOW_DELAY_MS = 20;
+var SIGINT_EXIT_CODE = 130;
+var SIGTERM_EXIT_CODE = 143;
+var SVELTE_CSS_LOAD_TIMEOUT_MS = 500;
+var TIME_PRECISION = 2;
+var TWO_THIRDS = 2 / 3;
+var UNFOUND_INDEX = -1;
+var WEBSOCKET_NORMAL_CLOSURE = 1000;
+var WORKSPACE_COMMAND_ARGS_OFFSET = 3;
+var WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30;
+var WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60;
+var WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000;
+var WORKSPACE_READY_PROBE_INTERVAL_MS = 250;
+var WORKSPACE_READY_TIMEOUT_MS = 30000;
+var WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4;
+var WORKSPACE_TUI_DEFAULT_HEIGHT = 28;
+var WORKSPACE_TUI_DEFAULT_WIDTH = 100;
+var WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30;
+var WORKSPACE_TUI_FOOTER_LINE_COUNT = 3;
+var WORKSPACE_TUI_MIN_LOG_HEIGHT = 3;
+var WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7;
+var WORKSPACE_TUI_MIN_TARGET_WIDTH = 8;
+var WORKSPACE_TUI_MIN_WRAP_WIDTH = 12;
+var WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3;
+var WORKSPACE_TUI_RECENT_LOG_LIMIT = 40;
+var WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16;
+var WORKSPACE_TUI_STATUS_WIDTH = 10;
+var WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6;
+var WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
+
+export { ANGULAR_INIT_TIMEOUT_MS, ANSI_ESCAPE_CODE, ANSI_ESCAPE_LENGTH, ASCII_SPACE, BASE_36_RADIX, BUN_BUILD_WARNING_SUPPRESSION, BODY_SLICE_LENGTH, BYTES_PER_KILOBYTE, CLI_ARGS_OFFSET, CSS_ERROR_RESOLVE_DELAY_MS, CSS_MAX_CHECK_ATTEMPTS, CSS_MAX_PARSE_TIMEOUT_MS, CSS_SHEET_READY_TIMEOUT_MS, DEFAULT_CHUNK_SIZE, DEFAULT_DEBOUNCE_MS, DEFAULT_PORT, DEV_SERVER_RESTART_DEBOUNCE_MS, DOM_UPDATE_DELAY_MS, FILE_PROTOCOL_PREFIX_LENGTH, FOCUS_ID_PREFIX_LENGTH, FOCUS_IDX_PREFIX_LENGTH, FOCUS_NAME_PREFIX_LENGTH, HMR_UPDATE_TIMEOUT_MS, HOOK_SIGNATURE_LENGTH, EXCLUDE_LAST_OFFSET, HTTP_STATUS_OK, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_NOT_FOUND, HOURS_IN_DAY, HOURS_IN_HALF_DAY, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY, IMAGE_GLOB_SUFFIX_LENGTH, MAX_ERROR_LENGTH, MAX_RECONNECT_ATTEMPTS, MILLISECONDS_IN_A_SECOND, MINUTES_IN_AN_HOUR, SECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS, PING_INTERVAL_MS, RAF_BATCH_COUNT, RANDOM_ID_END_INDEX, REBUILD_BATCH_DELAY_MS, REBUILD_RELOAD_DELAY_MS, RECONNECT_INITIAL_DELAY_MS, RECONNECT_POLL_INTERVAL_MS, REACT_STREAM_SLOT_FAST_DELAY_MS, REACT_STREAM_SLOT_SLOW_DELAY_MS, SIGINT_EXIT_CODE, SIGTERM_EXIT_CODE, SVELTE_CSS_LOAD_TIMEOUT_MS, TIME_PRECISION, TWO_THIRDS, UNFOUND_INDEX, WEBSOCKET_NORMAL_CLOSURE, WORKSPACE_COMMAND_ARGS_OFFSET, WORKSPACE_FAILURE_LOG_PRINT_LIMIT, WORKSPACE_FAILURE_RECENT_LOG_LIMIT, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS, WORKSPACE_READY_PROBE_INTERVAL_MS, WORKSPACE_READY_TIMEOUT_MS, WORKSPACE_SHUTDOWN_TIMEOUT_MS, WORKSPACE_TUI_DEFAULT_HEIGHT, WORKSPACE_TUI_DEFAULT_WIDTH, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS, WORKSPACE_TUI_FOOTER_LINE_COUNT, WORKSPACE_TUI_MIN_LOG_HEIGHT, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH, WORKSPACE_TUI_MIN_TARGET_WIDTH, WORKSPACE_TUI_MIN_WRAP_WIDTH, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET, WORKSPACE_TUI_RECENT_LOG_LIMIT, WORKSPACE_TUI_RENDER_DEBOUNCE_MS, WORKSPACE_TUI_STATUS_WIDTH, WORKSPACE_TUI_TARGET_PADDING_WIDTH, WORKSPACE_TUI_VISIBILITY_WIDTH };
+
+//# debugId=184C612842E6A07D64756E2164756E21
+//# sourceMappingURL=chunk-qh75agse.js.map

package/dist/chunk-qh75agse.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/constants.ts"],
+  "sourcesContent": [
+    "export const ANGULAR_INIT_TIMEOUT_MS = 500;\nexport const ANSI_ESCAPE_CODE = 27;\nexport const ANSI_ESCAPE_LENGTH = 3;\nexport const ASCII_SPACE = 32;\nexport const BASE_36_RADIX = 36;\nexport const BUN_BUILD_WARNING_SUPPRESSION =\n\t'wildcard sideEffects are not supported yet';\nexport const BODY_SLICE_LENGTH = 2000;\nexport const BYTES_PER_KILOBYTE = 1024;\nexport const CLI_ARGS_OFFSET = 3;\nexport const CSS_ERROR_RESOLVE_DELAY_MS = 50;\nexport const CSS_MAX_CHECK_ATTEMPTS = 10;\nexport const CSS_MAX_PARSE_TIMEOUT_MS = 500;\nexport const CSS_SHEET_READY_TIMEOUT_MS = 100;\nexport const DEFAULT_CHUNK_SIZE = 16_384;\nexport const DEFAULT_DEBOUNCE_MS = 15;\nexport const DEFAULT_PORT = 3000;\nexport const DEV_SERVER_RESTART_DEBOUNCE_MS = 100;\nexport const DOM_UPDATE_DELAY_MS = 50;\nexport const FILE_PROTOCOL_PREFIX_LENGTH = 7;\nexport const FOCUS_ID_PREFIX_LENGTH = 3;\nexport const FOCUS_IDX_PREFIX_LENGTH = 4;\nexport const FOCUS_NAME_PREFIX_LENGTH = 5;\nexport const HMR_UPDATE_TIMEOUT_MS = 2000;\nexport const HOOK_SIGNATURE_LENGTH = 12;\nexport const EXCLUDE_LAST_OFFSET = -1;\nexport const HTTP_STATUS_OK = 200;\nexport const HTTP_STATUS_BAD_REQUEST = 400;\nexport const HTTP_STATUS_NOT_FOUND = 404;\nexport const HOURS_IN_DAY = 24;\nexport const HOURS_IN_HALF_DAY = 12;\nexport const IMAGE_DEFAULT_DEVICE_SIZES = [\n\t640, 750, 828, 1080, 1200, 1920, 2048, 3840\n];\nexport const IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];\nexport const IMAGE_DEFAULT_QUALITY = 75;\nexport const IMAGE_GLOB_SUFFIX_LENGTH = 2;\nexport const MAX_ERROR_LENGTH = 200;\nexport const MAX_RECONNECT_ATTEMPTS = 60;\nexport const MILLISECONDS_IN_A_SECOND = 1000;\nexport const MINUTES_IN_AN_HOUR = 60;\nexport const SECONDS_IN_A_MINUTE = 60;\nexport const MILLISECONDS_IN_A_MINUTE =\n\tMILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;\nexport const MILLISECONDS_IN_A_DAY =\n\tMILLISECONDS_IN_A_SECOND *\n\tSECONDS_IN_A_MINUTE *\n\tMINUTES_IN_AN_HOUR *\n\tHOURS_IN_DAY;\nexport const OVERLAY_FADE_DURATION_MS = 150;\nexport const PING_INTERVAL_MS = 30_000;\nexport const RAF_BATCH_COUNT = 3;\nexport const RANDOM_ID_END_INDEX = 11;\nexport const REBUILD_BATCH_DELAY_MS = 10;\nexport const REBUILD_RELOAD_DELAY_MS = 200;\nexport const RECONNECT_INITIAL_DELAY_MS = 500;\nexport const RECONNECT_POLL_INTERVAL_MS = 300;\nexport const REACT_STREAM_SLOT_FAST_DELAY_MS = 5;\nexport const REACT_STREAM_SLOT_SLOW_DELAY_MS = 20;\nexport const SIGINT_EXIT_CODE = 130;\nexport const SIGTERM_EXIT_CODE = 143;\nexport const SVELTE_CSS_LOAD_TIMEOUT_MS = 500;\nexport const TIME_PRECISION = 2;\nexport const TWO_THIRDS = 2 / 3;\nexport const UNFOUND_INDEX = -1;\nexport const WEBSOCKET_NORMAL_CLOSURE = 1000;\nexport const WORKSPACE_COMMAND_ARGS_OFFSET = 3;\nexport const WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30;\nexport const WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60;\nexport const WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5_000;\nexport const WORKSPACE_READY_PROBE_INTERVAL_MS = 250;\nexport const WORKSPACE_READY_TIMEOUT_MS = 30_000;\nexport const WORKSPACE_SHUTDOWN_TIMEOUT_MS = 10_000;\nexport const WORKSPACE_TUI_DEFAULT_HEIGHT = 28;\nexport const WORKSPACE_TUI_DEFAULT_WIDTH = 100;\nexport const WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30;\nexport const WORKSPACE_TUI_FOOTER_LINE_COUNT = 3;\nexport const WORKSPACE_TUI_MIN_LOG_HEIGHT = 3;\nexport const WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7;\nexport const WORKSPACE_TUI_MIN_TARGET_WIDTH = 8;\nexport const WORKSPACE_TUI_MIN_WRAP_WIDTH = 12;\nexport const WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3;\nexport const WORKSPACE_TUI_RECENT_LOG_LIMIT = 40;\nexport const WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16;\nexport const WORKSPACE_TUI_STATUS_WIDTH = 10;\nexport const WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6;\nexport const WORKSPACE_TUI_VISIBILITY_WIDTH = 8;\n"
+  ],
+  "mappings": ";;AAAO,IAAM,0BAA0B;AAChC,IAAM,mBAAmB;AACzB,IAAM,qBAAqB;AAC3B,IAAM,cAAc;AACpB,IAAM,gBAAgB;AACtB,IAAM,gCACZ;AACM,IAAM,oBAAoB;AAC1B,IAAM,qBAAqB;AAC3B,IAAM,kBAAkB;AACxB,IAAM,6BAA6B;AACnC,IAAM,yBAAyB;AAC/B,IAAM,2BAA2B;AACjC,IAAM,6BAA6B;AACnC,IAAM,qBAAqB;AAC3B,IAAM,sBAAsB;AAC5B,IAAM,eAAe;AACrB,IAAM,iCAAiC;AACvC,IAAM,sBAAsB;AAC5B,IAAM,8BAA8B;AACpC,IAAM,yBAAyB;AAC/B,IAAM,0BAA0B;AAChC,IAAM,2BAA2B;AACjC,IAAM,wBAAwB;AAC9B,IAAM,wBAAwB;AAC9B,IAAM,sBAAsB;AAC5B,IAAM,iBAAiB;AACvB,IAAM,0BAA0B;AAChC,IAAM,wBAAwB;AAC9B,IAAM,eAAe;AACrB,IAAM,oBAAoB;AAC1B,IAAM,6BAA6B;AAAA,EACzC;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AACxC;AACO,IAAM,4BAA4B,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,GAAG;AACpE,IAAM,wBAAwB;AAC9B,IAAM,2BAA2B;AACjC,IAAM,mBAAmB;AACzB,IAAM,yBAAyB;AAC/B,IAAM,2BAA2B;AACjC,IAAM,qBAAqB;AAC3B,IAAM,sBAAsB;AAC5B,IAAM,2BACZ,2BAA2B;AACrB,IAAM,wBACZ,2BACA,sBACA,qBACA;AACM,IAAM,2BAA2B;AACjC,IAAM,mBAAmB;AACzB,IAAM,kBAAkB;AACxB,IAAM,sBAAsB;AAC5B,IAAM,yBAAyB;AAC/B,IAAM,0BAA0B;AAChC,IAAM,6BAA6B;AACnC,IAAM,6BAA6B;AACnC,IAAM,kCAAkC;AACxC,IAAM,kCAAkC;AACxC,IAAM,mBAAmB;AACzB,IAAM,oBAAoB;AAC1B,IAAM,6BAA6B;AACnC,IAAM,iBAAiB;AACvB,IAAM,aAAa,IAAI;AACvB,IAAM,gBAAgB;AACtB,IAAM,2BAA2B;AACjC,IAAM,gCAAgC;AACtC,IAAM,oCAAoC;AAC1C,IAAM,qCAAqC;AAC3C,IAAM,qCAAqC;AAC3C,IAAM,oCAAoC;AAC1C,IAAM,6BAA6B;AACnC,IAAM,gCAAgC;AACtC,IAAM,+BAA+B;AACrC,IAAM,8BAA8B;AACpC,IAAM,2CAA2C;AACjD,IAAM,kCAAkC;AACxC,IAAM,+BAA+B;AACrC,IAAM,uCAAuC;AAC7C,IAAM,iCAAiC;AACvC,IAAM,+BAA+B;AACrC,IAAM,qCAAqC;AAC3C,IAAM,iCAAiC;AACvC,IAAM,mCAAmC;AACzC,IAAM,6BAA6B;AACnC,IAAM,qCAAqC;AAC3C,IAAM,iCAAiC;",
+  "debugId": "184C612842E6A07D64756E2164756E21",
+  "names": []
+}

package/dist/chunk-qk8kd3hr.js

@@ -0,0 +1,526 @@
+// @bun
+import {
+  runWithStreamingSlotRegistry
+} from "./chunk-c1jfjnka.js";
+import {
+  appendStreamingSlotPatchesToStream
+} from "./chunk-sd39p726.js";
+import {
+  toPascal
+} from "./chunk-p5504p14.js";
+import {
+  BYTES_PER_KILOBYTE
+} from "./chunk-qh75agse.js";
+import {
+  __require
+} from "./chunk-bmgqm774.js";
+
+// src/core/responseEnhancers.ts
+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/islandPageContext.ts
+var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
+var ISLAND_MARKER = 'data-island="true"';
+var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
+var ISLAND_STATE_MARKER = "__ABS_ISLAND_STATE__";
+var CLOSING_HEAD_TAG = "</head>";
+var buildIslandsHeadMarkup = (manifest) => {
+  const manifestScript = `<script>window.__ABSOLUTE_MANIFEST__ = ${JSON.stringify(manifest)}</script>`;
+  const islandStateScript = `<script>window.__ABS_ISLAND_STATE__ = ${JSON.stringify(globalThis.__ABS_ISLAND_STATE__ ?? {})}</script>`;
+  const bootstrapPath = manifest[BOOTSTRAP_MANIFEST_KEY];
+  const bootstrapScript = bootstrapPath ? `<script type="module" src="${bootstrapPath}"></script>` : "";
+  return `${manifestScript}${islandStateScript}${bootstrapScript}`;
+};
+var injectHeadMarkup = (html, markup) => {
+  const closingHeadIndex = html.indexOf("</head>");
+  if (closingHeadIndex >= 0) {
+    return `${html.slice(0, closingHeadIndex)}${markup}${html.slice(closingHeadIndex)}`;
+  }
+  const openingBodyIndex = html.indexOf("<body");
+  if (openingBodyIndex >= 0) {
+    const bodyStart = html.indexOf(">", openingBodyIndex);
+    if (bodyStart >= 0) {
+      return `${html.slice(0, openingBodyIndex)}<head>${markup}</head>${html.slice(openingBodyIndex)}`;
+    }
+  }
+  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
+};
+var streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
+var flushSafePendingText = (controller, encoder, pending, lookbehind) => {
+  if (pending.length <= lookbehind) {
+    return pending;
+  }
+  const safeText = pending.slice(0, pending.length - lookbehind);
+  controller.enqueue(encoder.encode(safeText));
+  return pending.slice(-lookbehind);
+};
+var updateInjectedState = (consumed, injected, pending) => {
+  if (consumed.done) {
+    return { done: true, injected, pending };
+  }
+  return {
+    done: false,
+    injected: consumed.injected,
+    pending: consumed.pending
+  };
+};
+var readStreamChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  if (done || !value) {
+    return { done, value: undefined };
+  }
+  return { done, value };
+};
+var pipeStreamWithHeadInjection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = CLOSING_HEAD_TAG.length - 1;
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex >= 0) {
+      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishHeadInjectionStream = (controller, pending, injected) => {
+    let finalPending = pending + decoder.decode();
+    if (!injected) {
+      finalPending = injectHeadMarkup(finalPending, markup);
+    }
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeHeadChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runHeadInjectionLoop = async (controller, reader) => {
+    const consumeNextHeadChunk = async (injected, pending) => {
+      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextHeadChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextHeadChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
+        finishHeadInjectionStream(controller, pending, injected);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const 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/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 } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const ErrorComponent = mod.default;
+  const app = createSSRApp({
+    render: () => h(ErrorComponent, errorProps)
+  });
+  const rawBody = await renderToString(app);
+  const { styles, body } = unescapeVueStyles(rawBody);
+  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+};
+var renderAngularError = async (conventionPath, errorProps) => {
+  const mod = await import(conventionPath);
+  const 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 } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const NotFoundComponent = mod.default;
+  const app = createSSRApp({
+    render: () => h(NotFoundComponent)
+  });
+  const rawBody = await renderToString(app);
+  const { styles, body } = unescapeVueStyles(rawBody);
+  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+};
+var renderAngularNotFound = async (conventionPath) => {
+  const mod = await import(conventionPath);
+  const 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);
+};
+
+export { injectIslandPageContext, injectIslandPageContextStream, setCurrentIslandManifest, derivePageName, resolveErrorConventionPath, hasErrorConvention, setConventions, renderConventionError, renderFirstNotFound, enhanceHtmlResponseWithStreamingSlots, withStreamingSlots, withRegisteredStreamingSlots };
+
+//# debugId=C9D132C4A53F65BB64756E2164756E21
+//# sourceMappingURL=chunk-qk8kd3hr.js.map