@absolutejs/absolute 0.19.0-beta.1023 → 0.19.0-beta.1025

package/dist/cli/config/server.js

@@ -35275,7 +35275,6 @@ var ensureConfigCert = (host) => {
 };
 // src/constants.ts
 var BASE_36_RADIX = 36;
-var BYTES_PER_KILOBYTE = 1024;
 var CONFIG_DEFAULT_HOST = "config.absolute.localhost";
 var CONFIG_DEFAULT_PORT = 4099;
 var HTTP_STATUS_BAD_REQUEST = 400;
@@ -35410,61 +35409,69 @@ var pipeStreamWithHeadInjection = (stream, markup) => {
 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 headLookbehind = CLOSING_HEAD_TAG.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
     }
-    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: "" };
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
   };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
+  const processHead = (controller, pending) => {
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex < 0) {
+      return {
+        held: "",
+        injected: false,
+        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
+        sawHead: false
+      };
     }
-    controller.close();
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
   };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
     }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
   };
-  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 };
+  const finishMarkerStream = (controller, state) => {
+    const tail = decoder.decode();
+    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
+    enqueue(controller, remainder);
+    controller.close();
+  };
+  const runMarkerLoop = (controller, reader) => {
+    const consumeNext = async (state) => {
+      const { done, value } = await readStreamChunk(reader);
+      if (done || !value) {
+        return state;
       }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+      return consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
     };
-    return consumeNextIslandChunk(false, "");
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
   };
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
       try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
       } catch (error) {
         controller.error(error);
       }

package/dist/cli/index.js

@@ -55,6 +55,16 @@ var init_constants = __esm(() => {
   TWO_THIRDS = 2 / 3;
 });
 
+// src/dev/tunnel/protocol.ts
+var TUNNEL_CONTROL_PATH = "/__abs_tunnel/control", TUNNEL_FORWARDED_HOST_HEADER = "x-absolute-tunnel-host", decodeTunnelMessage = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}, encodeTunnelMessage = (message) => JSON.stringify(message);
+
 // src/utils/getDurationString.ts
 var getDurationString = (duration) => {
   let durationString;
@@ -172658,14 +172668,337 @@ var init_typecheck = __esm(() => {
   ];
 });
 
+// src/dev/tunnel/relay.ts
+var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObject = (headers) => {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}, startTunnelRelay = (options) => {
+  const port = options.port ?? (Number(process.env.PORT) || DEFAULT_RELAY_PORT);
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  let client = null;
+  const pending = new Map;
+  const publicSockets = new Map;
+  const resolvePublicUrl = (request) => {
+    if (options.publicUrl)
+      return options.publicUrl.replace(/\/$/, "");
+    const url = new URL(request.url);
+    const host = request.headers.get("x-forwarded-host") ?? url.host;
+    const proto = request.headers.get("x-forwarded-proto") ?? url.protocol.replace(":", "");
+    return `${proto}://${host}`;
+  };
+  const isWebSocketUpgrade = (request) => request.headers.get("upgrade")?.toLowerCase() === "websocket";
+  const server2 = Bun.serve({
+    port,
+    websocket: {
+      close(ws) {
+        if (ws.data.control) {
+          if (client === ws)
+            client = null;
+          return;
+        }
+        publicSockets.delete(ws.data.id);
+        client?.send(encodeTunnelMessage({ id: ws.data.id, type: "ws_close" }));
+      },
+      message(ws, raw) {
+        if (!ws.data.control) {
+          const binary = typeof raw !== "string";
+          const bytes = typeof raw === "string" ? Buffer.from(raw, "utf8") : Buffer.from(raw);
+          client?.send(encodeTunnelMessage({
+            binary,
+            dataBase64: bytes.toString("base64"),
+            id: ws.data.id,
+            type: "ws_data"
+          }));
+          return;
+        }
+        const message = decodeTunnelMessage(typeof raw === "string" ? raw : raw.toString());
+        if (!message)
+          return;
+        switch (message.type) {
+          case "ping":
+            ws.send(encodeTunnelMessage({ type: "pong" }));
+            break;
+          case "response":
+          case "error":
+            pending.get(message.id)?.(message);
+            break;
+          case "ws_open_ack":
+            if (!message.ok)
+              publicSockets.get(message.id)?.close();
+            break;
+          case "ws_data": {
+            const target = publicSockets.get(message.id);
+            const bytes = Buffer.from(message.dataBase64, "base64");
+            target?.send(message.binary ? bytes : bytes.toString("utf8"));
+            break;
+          }
+          case "ws_close":
+            publicSockets.get(message.id)?.close(message.code, message.reason);
+            publicSockets.delete(message.id);
+            break;
+          default:
+            break;
+        }
+      },
+      open(ws) {
+        if (ws.data.control) {
+          client = ws;
+          ws.send(encodeTunnelMessage({ publicUrl: options.publicUrl ?? "", type: "ready" }));
+          return;
+        }
+        publicSockets.set(ws.data.id, ws);
+        client?.send(encodeTunnelMessage({
+          headers: ws.data.headers,
+          id: ws.data.id,
+          type: "ws_open",
+          url: ws.data.url
+        }));
+      }
+    },
+    async fetch(request, srv) {
+      const url = new URL(request.url);
+      if (url.pathname === TUNNEL_CONTROL_PATH) {
+        if (url.searchParams.get("token") !== options.token) {
+          return new Response("Forbidden", { status: 403 });
+        }
+        const upgraded = srv.upgrade(request, { data: { control: true } });
+        return upgraded ? undefined : new Response("Upgrade failed", { status: 426 });
+      }
+      if (!client) {
+        return new Response("Tunnel offline: no dev client connected.", { status: 503 });
+      }
+      if (isWebSocketUpgrade(request)) {
+        const id2 = crypto.randomUUID();
+        const upgraded = srv.upgrade(request, {
+          data: {
+            control: false,
+            headers: headersToObject(request.headers),
+            id: id2,
+            url: url.pathname + url.search
+          }
+        });
+        return upgraded ? undefined : new Response("Upgrade failed", { status: 426 });
+      }
+      const id = crypto.randomUUID();
+      const bodyBytes = ["GET", "HEAD"].includes(request.method) ? null : new Uint8Array(await request.arrayBuffer());
+      const headers = headersToObject(request.headers);
+      headers[TUNNEL_FORWARDED_HOST_HEADER] = resolvePublicUrl(request);
+      const message = {
+        headers,
+        id,
+        method: request.method,
+        type: "request",
+        url: url.pathname + url.search,
+        ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
+      };
+      const responsePromise = new Promise((resolve14) => {
+        pending.set(id, resolve14);
+      });
+      client.send(encodeTunnelMessage(message));
+      const timeout = new Promise((resolve14) => setTimeout(() => resolve14({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const result = await Promise.race([responsePromise, timeout]);
+      pending.delete(id);
+      if (result.type === "error") {
+        return new Response(`Tunnel error: ${result.message}`, { status: 504 });
+      }
+      if (result.type !== "response") {
+        return new Response("Tunnel protocol error", { status: 502 });
+      }
+      return new Response(result.bodyBase64 ? Buffer.from(result.bodyBase64, "base64") : null, { headers: result.headers, status: result.status });
+    }
+  });
+  console.info(`[tunnel-relay] listening on :${server2.port} (control ${TUNNEL_CONTROL_PATH})`);
+  return server2;
+};
+var init_relay = () => {};
+
+// src/cli/scripts/tunnelRelay.ts
+var exports_tunnelRelay = {};
+__export(exports_tunnelRelay, {
+  tunnelRelay: () => tunnelRelay
+});
+var tunnelRelay = () => {
+  const token = process.env.ABSOLUTE_TUNNEL_TOKEN;
+  if (!token) {
+    console.error("[tunnel-relay] ABSOLUTE_TUNNEL_TOKEN is required.");
+    process.exit(1);
+  }
+  startTunnelRelay({
+    port: Number(process.env.PORT) || undefined,
+    publicUrl: process.env.ABSOLUTE_TUNNEL_PUBLIC_URL,
+    token
+  });
+};
+var init_tunnelRelay = __esm(() => {
+  init_relay();
+});
+
 // src/cli/scripts/dev.ts
 init_constants();
-init_startupBanner();
 var {$: $2, env } = globalThis.Bun;
 import { spawn as nodeSpawn } from "child_process";
 import { createWriteStream, existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve3 } from "path";
 
+// src/dev/tunnel/client.ts
+var RECONNECT_DELAY_MS = 2000;
+var controlSocketUrl = (relayUrl, token) => {
+  const url = new URL(relayUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = TUNNEL_CONTROL_PATH;
+  url.search = `?token=${encodeURIComponent(token)}`;
+  return url.toString();
+};
+var STRIPPED_REQUEST_HEADERS = new Set(["host", "connection", "content-length", TUNNEL_FORWARDED_HOST_HEADER]);
+var startTunnelClient = (options) => {
+  const publicUrl = options.relayUrl.replace(/\/$/, "");
+  const localWsOrigin = options.localOrigin.replace(/^http/, "ws");
+  let socket = null;
+  let closed = false;
+  let reconnectTimer = null;
+  const localSockets = new Map;
+  const sendFrameToRelay = (id, data, binary) => {
+    const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    const message = {
+      binary,
+      dataBase64: bytes.toString("base64"),
+      id,
+      type: "ws_data"
+    };
+    socket?.send(encodeTunnelMessage(message));
+  };
+  const openLocalWs = (id, url) => {
+    const local = new WebSocket(`${localWsOrigin}${url}`);
+    local.binaryType = "arraybuffer";
+    const entry = { pending: [], ready: false, ws: local };
+    localSockets.set(id, entry);
+    local.addEventListener("open", () => {
+      entry.ready = true;
+      socket?.send(encodeTunnelMessage({ id, ok: true, type: "ws_open_ack" }));
+      for (const frame of entry.pending) {
+        local.send(frame.binary ? frame.bytes : frame.bytes.toString("utf8"));
+      }
+      entry.pending = [];
+    });
+    local.addEventListener("message", (event) => {
+      if (typeof event.data === "string") {
+        sendFrameToRelay(id, event.data, false);
+      } else if (event.data instanceof ArrayBuffer) {
+        sendFrameToRelay(id, Buffer.from(event.data), true);
+      }
+    });
+    local.addEventListener("close", (event) => {
+      localSockets.delete(id);
+      socket?.send(encodeTunnelMessage({ code: event.code, id, type: "ws_close" }));
+    });
+    local.addEventListener("error", () => {
+      if (!entry.ready) {
+        socket?.send(encodeTunnelMessage({ error: "local ws failed", id, ok: false, type: "ws_open_ack" }));
+      }
+    });
+  };
+  const forwardFrameToLocal = (message) => {
+    const entry = localSockets.get(message.id);
+    if (!entry)
+      return;
+    const bytes = Buffer.from(message.dataBase64, "base64");
+    if (!entry.ready) {
+      entry.pending.push({ binary: message.binary, bytes });
+      return;
+    }
+    entry.ws.send(message.binary ? bytes : bytes.toString("utf8"));
+  };
+  const handleRequest = async (message) => {
+    const headers = {};
+    for (const [key, value] of Object.entries(message.headers)) {
+      if (!STRIPPED_REQUEST_HEADERS.has(key.toLowerCase()))
+        headers[key] = value;
+    }
+    try {
+      const response = await fetch(`${options.localOrigin}${message.url}`, {
+        body: message.bodyBase64 ? Buffer.from(message.bodyBase64, "base64") : undefined,
+        headers,
+        method: message.method,
+        redirect: "manual"
+      });
+      const bodyBytes = new Uint8Array(await response.arrayBuffer());
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      const reply = {
+        headers: responseHeaders,
+        id: message.id,
+        status: response.status,
+        type: "response",
+        ...bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
+      };
+      socket?.send(encodeTunnelMessage(reply));
+    } catch (error) {
+      socket?.send(encodeTunnelMessage({
+        id: message.id,
+        message: error instanceof Error ? error.message : String(error),
+        type: "error"
+      }));
+    }
+  };
+  const connect = () => {
+    if (closed)
+      return;
+    socket = new WebSocket(controlSocketUrl(options.relayUrl, options.token));
+    socket.addEventListener("message", (event) => {
+      const message = decodeTunnelMessage(String(event.data));
+      if (!message)
+        return;
+      switch (message.type) {
+        case "request":
+          handleRequest(message);
+          break;
+        case "ready":
+          options.onReady?.(publicUrl);
+          break;
+        case "ping":
+          socket?.send(encodeTunnelMessage({ type: "pong" }));
+          break;
+        case "ws_open":
+          openLocalWs(message.id, message.url);
+          break;
+        case "ws_data":
+          forwardFrameToLocal(message);
+          break;
+        case "ws_close":
+          localSockets.get(message.id)?.ws.close();
+          localSockets.delete(message.id);
+          break;
+        default:
+          break;
+      }
+    });
+    socket.addEventListener("close", () => {
+      if (closed)
+        return;
+      reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+    });
+    socket.addEventListener("error", () => {});
+  };
+  connect();
+  return {
+    publicUrl,
+    close() {
+      closed = true;
+      if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+      socket?.close();
+    }
+  };
+};
+
+// src/cli/scripts/dev.ts
+init_startupBanner();
+
 // src/cli/interactive.ts
 init_constants();
 import { openSync } from "fs";
@@ -173037,13 +173370,18 @@ var setupHttpsCert = async () => {
   }
   await setupCertWithPrompt(ensureDevCert2, setupMkcert2);
 };
-var resolveDevConfig = (configDev) => ({
-  port: Number(env.ABSOLUTE_PORT) || Number(env.PORT) || configDev?.port || DEFAULT_PORT,
-  portRange: Number(env.ABSOLUTE_PORT_RANGE) || configDev?.portRange || DEFAULT_PORT_RANGE,
-  strictPort: env.ABSOLUTE_STRICT_PORT === "true" || configDev?.strictPort === true,
-  host: env.ABSOLUTE_HOST ?? configDev?.host ?? "localhost",
-  https: env.ABSOLUTE_HTTPS === "true" || configDev?.https === true
-});
+var resolveDevConfig = (configDev) => {
+  const relay = env.ABSOLUTE_TUNNEL_RELAY ?? configDev?.tunnel?.relay;
+  const token = env.ABSOLUTE_TUNNEL_TOKEN ?? configDev?.tunnel?.token;
+  return {
+    host: env.ABSOLUTE_HOST ?? configDev?.host ?? "localhost",
+    https: env.ABSOLUTE_HTTPS === "true" || configDev?.https === true,
+    port: Number(env.ABSOLUTE_PORT) || Number(env.PORT) || configDev?.port || DEFAULT_PORT,
+    portRange: Number(env.ABSOLUTE_PORT_RANGE) || configDev?.portRange || DEFAULT_PORT_RANGE,
+    strictPort: env.ABSOLUTE_STRICT_PORT === "true" || configDev?.strictPort === true,
+    ...relay && token ? { tunnel: { relay, token } } : {}
+  };
+};
 var dev = async (serverEntry, configPath2) => {
   let httpsEnabled = false;
   let resolvedDev;
@@ -173078,7 +173416,7 @@ var dev = async (serverEntry, configPath2) => {
     console.error(cliTag("\x1B[31m", String(err.message ?? err)));
     process.exit(1);
   });
-  let port = initialPortProbe.port;
+  let { port } = initialPortProbe;
   if (initialPortProbe.fellBack) {
     const displayHost = resolvedDev.host === "0.0.0.0" ? "localhost" : resolvedDev.host;
     console.log(cliTag("\x1B[33m", `Port ${resolvedDev.port} is in use, trying another one... \u2192 http://${displayHost}:${port}/`));
@@ -173123,11 +173461,24 @@ var dev = async (serverEntry, configPath2) => {
   let cleaning = false;
   let interactive = null;
   let serverReady = false;
+  let tunnelClient = null;
+  const startTunnelIfConfigured = () => {
+    if (tunnelClient || !resolvedDev.tunnel)
+      return;
+    tunnelClient = startTunnelClient({
+      localOrigin: `http://localhost:${port}`,
+      relayUrl: resolvedDev.tunnel.relay,
+      token: resolvedDev.tunnel.token,
+      onReady: (publicUrl) => process.stdout.write(`  \x1B[32m\u279C\x1B[0m  \x1B[1mPublic:\x1B[0m  ${publicUrl}/
+`)
+    });
+  };
   const checkServerReady = (value) => {
     const chunk = value.toString();
     if (!chunk.includes("Local:"))
       return;
     serverReady = true;
+    startTunnelIfConfigured();
     interactive?.showPrompt();
   };
   const RESTART_MARKER = "[abs:restart]";
@@ -173391,6 +173742,7 @@ var dev = async (serverEntry, configPath2) => {
     });
     if (interactive)
       interactive.dispose();
+    tunnelClient?.close();
     if (paused)
       sendSignal("SIGCONT");
     killChildTree("SIGTERM");
@@ -175905,6 +176257,10 @@ if (command === "dev") {
   sendTelemetryEvent("cli:command", { command });
   const { setupMkcert: setupMkcert2 } = await Promise.resolve().then(() => (init_devCert(), exports_devCert));
   setupMkcert2();
+} else if (command === "tunnel-relay") {
+  sendTelemetryEvent("cli:command", { command });
+  const { tunnelRelay: tunnelRelay2 } = await Promise.resolve().then(() => (init_tunnelRelay(), exports_tunnelRelay));
+  tunnelRelay2();
 } else {
   const message = command ? `Unknown command: ${command}` : "No command specified";
   console.error(message);
@@ -175922,5 +176278,6 @@ if (command === "dev") {
   console.error("  prettier      Run Prettier check (cached)");
   console.error("  typecheck     Run type checkers for all frameworks");
   console.error("  telemetry     Manage anonymous telemetry");
+  console.error("  tunnel-relay  Run the public reverse-tunnel relay (for webhook dev)");
   process.exit(1);
 }

package/dist/client/index.js

@@ -259,12 +259,20 @@ __export(exports_react, {
 });
 import { createElement } from "react";
 import { hydrateRoot } from "react-dom/client";
-var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && value !== null, isReactComponent = (value) => typeof value === "function", hydrateReactIsland = (component, element, props) => {
+var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && value !== null, HOST_REACT_EXPANDO_PREFIXES, detachFromHostReactRoot = (element) => {
+  for (const key of Object.keys(element)) {
+    const isHostExpando = HOST_REACT_EXPANDO_PREFIXES.some((prefix) => key.startsWith(prefix));
+    if (!isHostExpando)
+      continue;
+    Reflect.deleteProperty(element, key);
+  }
+}, isReactComponent = (value) => typeof value === "function", hydrateReactIsland = (component, element, props) => {
   const existingRoot = reactIslandRoots.get(element);
   if (existingRoot) {
     existingRoot.render(isPropsRecord(props) ? createElement(component, props) : createElement(component));
     return;
   }
+  detachFromHostReactRoot(element);
   if (!isPropsRecord(props)) {
     reactIslandRoots.set(element, hydrateRoot(element, createElement(component)));
     return;
@@ -273,6 +281,14 @@ var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && va
 };
 var init_react = __esm(() => {
   reactIslandRoots = new WeakMap;
+  HOST_REACT_EXPANDO_PREFIXES = [
+    "__reactFiber$",
+    "__reactProps$",
+    "__reactContainer$",
+    "__reactEvents$",
+    "__reactListeners$",
+    "__reactHandles$"
+  ];
 });
 
 // src/client/hydrators/svelte.ts
@@ -524,9 +540,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -782,9 +801,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   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 { Component, InjectionToken, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken(`${wrapperKey}:props`);
 
@@ -1014,13 +1032,6 @@ init_islands();
 
 // 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;
@@ -1079,19 +1090,22 @@ var preserveIslandMarkup = (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);
+  const snapshotCandidate = snapshotMap?.get(signature)?.[0];
+  if (snapshotCandidate) {
+    return snapshotCandidate;
+  }
+  const liveCandidate = Array.from(document.querySelectorAll('[data-island="true"]')).find((element) => isMatchingIslandElement(element, props));
+  if (!liveCandidate) {
+    return {
+      attributes: getIslandMarkerAttributes(props),
+      innerHTML: ""
+    };
   }
   return {
-    attributes: snapshotCandidate?.attributes ?? getIslandMarkerAttributes(props),
-    innerHTML: snapshotCandidate?.innerHTML ?? candidate?.innerHTML ?? ""
+    attributes: Object.fromEntries(liveCandidate.getAttributeNames().map((name) => [name, liveCandidate.getAttribute(name) ?? ""])),
+    innerHTML: liveCandidate.innerHTML
   };
 };
 
@@ -1242,5 +1256,5 @@ export {
   createIslandManifestResolver
 };
 
-//# debugId=48A5E34EBDE550F464756E2164756E21
+//# debugId=07B15BB8DBC2C0A764756E2164756E21
 //# sourceMappingURL=index.js.map