@nuxt/scripts 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/runtime/registry/schemas.js

@@ -753,6 +753,34 @@ export const RedditPixelOptions = object({
    */
   id: string()
 });
+export const PulseAnalyticsOptions = object({
+  /**
+   * The site domain as registered in Pulse.
+   * @see https://docs.ciphera.net/pulse/script-installation
+   */
+  domain: string(),
+  /**
+   * The API origin the tracker posts events to. Only needed for a self-hosted
+   * or reverse-proxied Pulse API.
+   * @default 'https://pulse-api.ciphera.net'
+   */
+  apiUrl: optional(string()),
+  /**
+   * Record scroll depth.
+   * @default true
+   */
+  trackScroll: optional(boolean()),
+  /**
+   * Record outbound link clicks as `outbound_link` events.
+   * @default true
+   */
+  trackOutbound: optional(boolean()),
+  /**
+   * Record file download clicks as `file_download` events.
+   * @default true
+   */
+  trackDownloads: optional(boolean())
+});
 export const RybbitAnalyticsOptions = object({
   /**
    * Your Rybbit site ID.
@@ -1107,6 +1135,20 @@ export const StripeOptions = object({
    */
   version: optional(union([literal("v3"), literal("acacia"), literal("basil"), literal("clover"), literal("dahlia"), string()]))
 });
+export const TawkToOptions = object({
+  /**
+   * Your Tawk.to property ID: the first path segment of the widget embed URL
+   * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+   * @see https://dashboard.tawk.to/
+   */
+  propertyId: pipe(string(), minLength(1)),
+  /**
+   * Your Tawk.to widget ID: the second path segment of the widget embed URL
+   * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+   * @see https://dashboard.tawk.to/
+   */
+  widgetId: pipe(string(), minLength(1))
+});
 export const TikTokPixelOptions = object({
   /**
    * Your TikTok Pixel ID.

package/dist/runtime/registry/tawk-to.d.ts

@@ -0,0 +1,126 @@
+import type { Ref } from 'vue';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { TawkToOptions } from './schemas.js';
+export { TawkToOptions };
+export type TawkToInput = RegistryScriptInput<typeof TawkToOptions, false, false>;
+export type TawkToStatus = 'online' | 'away' | 'offline';
+export type TawkToWindowType = 'inline' | 'embed';
+export type TawkToWidgetPosition = 'br' | 'bl' | 'cr' | 'cl' | 'tr' | 'tl';
+export interface TawkToVisitor {
+    name?: string;
+    email?: string;
+    /** Visitor phone number in E.164 format (e.g. `+15551234567`). */
+    phone?: string;
+    /** HMAC-SHA256 signature for Tawk's Secure Mode, generated server-side by the consumer. */
+    hash?: string;
+}
+/**
+ * The `window.Tawk_API` surface, as exposed through `proxy`. `proxy` is
+ * fire-and-forget: unhead's script proxy queues/replays calls but always
+ * discards their return value, even once the script is fully loaded (and it
+ * has no `set` trap, so plain property assignment through it goes nowhere).
+ * That means only void-returning actions belong here - real getters and the
+ * `visitor` setter live on `useScriptTawkTo()`'s own return value instead
+ * (see `TawkToEvents`), backed directly by `window.Tawk_API`.
+ * @see https://developer.tawk.to/jsapi/
+ */
+export interface TawkToApi {
+    /** Starts the chat. Pass `{ showWidget: true }` to also show the widget. */
+    start: (options?: {
+        showWidget?: boolean;
+    }) => void;
+    shutdown: () => void;
+    maximize: () => void;
+    minimize: () => void;
+    toggle: () => void;
+    popup: () => void;
+    showWidget: () => void;
+    hideWidget: () => void;
+    toggleVisibility: () => void;
+    endChat: () => void;
+    getWindowType: () => TawkToWindowType;
+    getStatus: () => TawkToStatus;
+    isChatMaximized: () => boolean;
+    isChatMinimized: () => boolean;
+    isChatHidden: () => boolean;
+    isChatOngoing: () => boolean;
+    isVisitorEngaged: () => boolean;
+    /** Set by Tawk once the widget has finished loading. The embed writes a boolean (`!0`), not a number. */
+    onLoaded?: boolean;
+    /** Set by Tawk before the widget begins loading. */
+    onBeforeLoaded?: boolean;
+    widgetPosition: () => TawkToWidgetPosition;
+    visitor?: TawkToVisitor;
+    setAttributes: (attributes: Record<string, string>, callback?: (error: Error | null) => void) => void;
+    addEvent: (event: string, metadata?: Record<string, unknown>, callback?: (error: Error | null) => void) => void;
+    addTags: (tags: string[], callback?: (error: Error | null) => void) => void;
+    removeTags: (tags: string[], callback?: (error: Error | null) => void) => void;
+    switchWidget: (data: {
+        propertyId: string;
+        widgetId: string;
+    }, callback?: (error: Error | null) => void) => void;
+}
+declare global {
+    interface Window {
+        Tawk_API?: TawkToApi;
+        Tawk_LoadStart?: Date;
+    }
+}
+/**
+ * The subset of `TawkToApi` that `proxy` actually exposes: the getters, the
+ * `visitor` setter and the `onLoaded`/`onBeforeLoaded` flags are omitted since
+ * none of them work through the fire-and-forget proxy (see `TawkToApi`'s doc
+ * comment). They're still real members of the underlying `window.Tawk_API`
+ * object, just not reachable via `proxy`.
+ */
+export type TawkToProxyApi = Omit<TawkToApi, 'getWindowType' | 'getStatus' | 'isChatMaximized' | 'isChatMinimized' | 'isChatHidden' | 'isChatOngoing' | 'isVisitorEngaged' | 'widgetPosition' | 'visitor' | 'onLoaded' | 'onBeforeLoaded'>;
+/**
+ * Reactive state and typed event listeners bridged from the `window`
+ * `CustomEvent`s Tawk's embed script dispatches (`tawkLoad`, `tawkStatusChange`, etc).
+ * These aren't part of the documented `Tawk_API.onXxx = fn` callback-property API -
+ * they're a separate, verified-in-the-browser signal the embed script also fires.
+ */
+export interface TawkToEvents {
+    isHidden: Readonly<Ref<boolean>>;
+    isMinimized: Readonly<Ref<boolean>>;
+    isMaximized: Readonly<Ref<boolean>>;
+    /** The operator status Tawk reports (`getStatus()`) — not to be confused with `status`, the script's own load state. */
+    chatStatus: Readonly<Ref<TawkToStatus>>;
+    unreadCount: Readonly<Ref<number>>;
+    getWindowType: () => TawkToWindowType | undefined;
+    getStatus: () => TawkToStatus | undefined;
+    isChatMaximized: () => boolean;
+    isChatMinimized: () => boolean;
+    isChatHidden: () => boolean;
+    isChatOngoing: () => boolean;
+    isVisitorEngaged: () => boolean;
+    widgetPosition: () => TawkToWidgetPosition | undefined;
+    /**
+     * Sets `Tawk_API.visitor` directly - assigning through `proxy.visitor` is a no-op
+     * (no `set` trap). Pre-insertion only: Tawk honors `Tawk_API.visitor` until the
+     * embed script is requested, so a call after that warns and does nothing - use
+     * `window.Tawk_API.setAttributes()` for post-load identity changes.
+     */
+    setVisitor: (data: TawkToVisitor) => void;
+    onLoad: (cb: () => void) => () => void;
+    onBeforeLoad: (cb: () => void) => () => void;
+    onStatusChange: (cb: (status: TawkToStatus) => void) => () => void;
+    onChatMaximized: (cb: () => void) => () => void;
+    onChatMinimized: (cb: () => void) => () => void;
+    onChatHidden: (cb: () => void) => () => void;
+    onChatStarted: (cb: () => void) => () => void;
+    onChatEnded: (cb: () => void) => () => void;
+    onPrechatSubmit: (cb: (data: Record<string, unknown>) => void) => () => void;
+    onOfflineSubmit: (cb: (data: Record<string, unknown>) => void) => () => void;
+    onChatMessageVisitor: (cb: (message: string) => void) => () => void;
+    onChatMessageAgent: (cb: (message: string) => void) => () => void;
+    onChatMessageSystem: (cb: (message: string) => void) => () => void;
+    onAgentJoinChat: (cb: (data: Record<string, unknown>) => void) => () => void;
+    onAgentLeaveChat: (cb: (data: Record<string, unknown>) => void) => () => void;
+    onChatSatisfaction: (cb: (satisfaction: number) => void) => () => void;
+    onVisitorNameChanged: (cb: (visitorName: string) => void) => () => void;
+    onFileUpload: (cb: (link: string) => void) => () => void;
+    onTagsUpdated: (cb: (data: Record<string, unknown>) => void) => () => void;
+    onUnreadCountChanged: (cb: (count: number) => void) => () => void;
+}
+export declare function useScriptTawkTo<T extends TawkToProxyApi>(_options?: TawkToInput): UseScriptContext<T> & TawkToEvents;

package/dist/runtime/registry/tawk-to.js

@@ -0,0 +1,147 @@
+import { joinURL } from "ufo";
+import { ref } from "vue";
+import { useRegistryScript } from "../utils.js";
+import { TawkToOptions } from "./schemas.js";
+export { TawkToOptions };
+const isHidden = ref(false);
+const isMinimized = ref(false);
+const isMaximized = ref(false);
+const chatStatus = ref("offline");
+const unreadCount = ref(0);
+function listen(event, cb) {
+  if (import.meta.server)
+    return () => {
+    };
+  const handler = (e) => cb(e.detail);
+  window.addEventListener(event, handler);
+  return () => window.removeEventListener(event, handler);
+}
+let stateBridged = false;
+function ensureStateBridge() {
+  if (stateBridged)
+    return;
+  stateBridged = true;
+  listen("tawkLoad", () => {
+    isHidden.value = !!window.Tawk_API?.isChatHidden?.();
+    isMinimized.value = !!window.Tawk_API?.isChatMinimized?.();
+    isMaximized.value = !!window.Tawk_API?.isChatMaximized?.();
+    chatStatus.value = window.Tawk_API?.getStatus?.() ?? "offline";
+  });
+  listen("tawkStatusChange", (detail) => {
+    chatStatus.value = detail;
+  });
+  listen("tawkChatHidden", () => {
+    isHidden.value = true;
+  });
+  listen("tawkChatMinimized", () => {
+    isMinimized.value = true;
+    isMaximized.value = false;
+  });
+  listen("tawkChatMaximized", () => {
+    isMaximized.value = true;
+    isMinimized.value = false;
+  });
+  listen("tawkUnreadCountChanged", (detail) => {
+    unreadCount.value = detail;
+  });
+}
+function resyncHiddenState() {
+  if (import.meta.server)
+    return;
+  isHidden.value = !!window.Tawk_API?.isChatHidden?.();
+}
+const visibilityCommands = /* @__PURE__ */ new Set(["hideWidget", "showWidget", "toggleVisibility"]);
+const TAWK_PROXY_DECORATED = Symbol("nuxt-scripts.tawk-proxy-decorated");
+export function useScriptTawkTo(_options) {
+  const instance = useRegistryScript("tawkTo", (options) => ({
+    scriptInput: {
+      src: joinURL("https://embed.tawk.to", options.propertyId, options.widgetId),
+      async: true,
+      crossorigin: "anonymous"
+    },
+    schema: import.meta.dev ? TawkToOptions : void 0,
+    scriptOptions: {
+      resolve({ waitFor }) {
+        if (window.Tawk_API?.onLoaded)
+          return window.Tawk_API;
+        return waitFor((resolve, reject) => {
+          const stop = listen("tawkLoad", () => {
+            stop();
+            if (window.Tawk_API)
+              resolve(window.Tawk_API);
+            else
+              reject(new Error("[nuxt-scripts] Tawk.to reported ready without exposing window.Tawk_API"));
+          });
+          return stop;
+        });
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.Tawk_API = window.Tawk_API || {};
+      window.Tawk_LoadStart = /* @__PURE__ */ new Date();
+    }
+  }), _options);
+  if (!import.meta.server) {
+    ensureStateBridge();
+    const shared = instance.script || instance;
+    if (shared.proxy && !shared[TAWK_PROXY_DECORATED]) {
+      shared.proxy = new Proxy(shared.proxy, {
+        get(target, prop, receiver) {
+          const value = Reflect.get(target, prop, receiver);
+          if (!(typeof prop === "string" && visibilityCommands.has(prop)) || typeof value !== "function")
+            return value;
+          return (...args) => {
+            ;
+            value(...args);
+            resyncHiddenState();
+          };
+        }
+      });
+      Object.defineProperty(shared, TAWK_PROXY_DECORATED, { value: true });
+    }
+  }
+  instance.isHidden = isHidden;
+  instance.isMinimized = isMinimized;
+  instance.isMaximized = isMaximized;
+  instance.chatStatus = chatStatus;
+  instance.unreadCount = unreadCount;
+  instance.onLoad = (cb) => listen("tawkLoad", cb);
+  instance.onBeforeLoad = (cb) => listen("tawkBeforeLoad", cb);
+  instance.onStatusChange = (cb) => listen("tawkStatusChange", cb);
+  instance.onChatMaximized = (cb) => listen("tawkChatMaximized", cb);
+  instance.onChatMinimized = (cb) => listen("tawkChatMinimized", cb);
+  instance.onChatHidden = (cb) => listen("tawkChatHidden", cb);
+  instance.onChatStarted = (cb) => listen("tawkChatStarted", cb);
+  instance.onChatEnded = (cb) => listen("tawkChatEnded", cb);
+  instance.onPrechatSubmit = (cb) => listen("tawkPrechatSubmit", cb);
+  instance.onOfflineSubmit = (cb) => listen("tawkOfflineSubmit", cb);
+  instance.onChatMessageVisitor = (cb) => listen("tawkChatMessageVisitor", cb);
+  instance.onChatMessageAgent = (cb) => listen("tawkChatMessageAgent", cb);
+  instance.onChatMessageSystem = (cb) => listen("tawkChatMessageSystem", cb);
+  instance.onAgentJoinChat = (cb) => listen("tawkAgentJoinChat", cb);
+  instance.onAgentLeaveChat = (cb) => listen("tawkAgentLeaveChat", cb);
+  instance.onChatSatisfaction = (cb) => listen("tawkChatSatisfaction", cb);
+  instance.onVisitorNameChanged = (cb) => listen("tawkVisitorNameChanged", cb);
+  instance.onFileUpload = (cb) => listen("tawkFileUpload", cb);
+  instance.onTagsUpdated = (cb) => listen("tawkTagsUpdated", cb);
+  instance.onUnreadCountChanged = (cb) => listen("tawkUnreadCountChanged", cb);
+  instance.getWindowType = () => import.meta.server ? void 0 : window.Tawk_API?.getWindowType?.();
+  instance.getStatus = () => import.meta.server ? void 0 : window.Tawk_API?.getStatus?.();
+  instance.isChatMaximized = () => !import.meta.server && !!window.Tawk_API?.isChatMaximized?.();
+  instance.isChatMinimized = () => !import.meta.server && !!window.Tawk_API?.isChatMinimized?.();
+  instance.isChatHidden = () => !import.meta.server && !!window.Tawk_API?.isChatHidden?.();
+  instance.isChatOngoing = () => !import.meta.server && !!window.Tawk_API?.isChatOngoing?.();
+  instance.isVisitorEngaged = () => !import.meta.server && !!window.Tawk_API?.isVisitorEngaged?.();
+  instance.widgetPosition = () => import.meta.server ? void 0 : window.Tawk_API?.widgetPosition?.();
+  instance.setVisitor = (data) => {
+    if (import.meta.server)
+      return;
+    window.Tawk_API = window.Tawk_API || {};
+    if (instance.status.value !== "awaitingLoad" || window.Tawk_API.onLoaded) {
+      console.warn("[nuxt-scripts] Tawk.to: setVisitor() only works before the widget script is inserted. Tawk drops visitor data written after that - set it before the widget loads, or use window.Tawk_API.setAttributes({ name, email, phone, hash }) afterwards.");
+      return;
+    }
+    window.Tawk_API.visitor = data;
+  };
+  return instance;
+}

package/dist/runtime/server/proxy-handler.d.ts

@@ -1,8 +1,4 @@
 export declare const SKIP_REQUEST_HEADERS: Set<string>;
 export declare function withResponseBodyIdleTimeout(body: ReadableStream<Uint8Array>, timeoutMs: number, onTimeout: () => void): ReadableStream<Uint8Array>;
-/**
- * Privacy-aware proxy handler for first-party script collection endpoints.
- * Routes requests to third-party analytics while protecting user privacy.
- */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | null>>;
 export default _default;

package/dist/runtime/server/proxy-handler.js

@@ -15,6 +15,9 @@ const COMPRESSION_RE = /gzip|deflate|br|compress|base64/i;
 const CLIENT_HINT_VERSION_RE = /;v="(\d+)\.[^"]*"/g;
 const MAX_TRANSFORM_BODY_SIZE = 2 * 1024 * 1024;
 const UPSTREAM_TIMEOUT_MS = 15e3;
+const MAX_UPSTREAM_REDIRECTS = 5;
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+const REQUEST_BODY_HEADERS = ["content-encoding", "content-language", "content-length", "content-location", "content-type"];
 const SKIP_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
   "alt-svc",
   "clear-site-data",
@@ -46,7 +49,7 @@ export const SKIP_REQUEST_HEADERS = /* @__PURE__ */ new Set([
   "transfer-encoding",
   "upgrade"
 ]);
-async function readTransformBody(event) {
+async function readBodyBytes(event) {
   const contentLength = Number(getHeaders(event)["content-length"] || 0);
   if (Number.isFinite(contentLength) && contentLength > MAX_TRANSFORM_BODY_SIZE) {
     throw createError({ statusCode: 413, statusMessage: "Proxy request body too large" });
@@ -83,7 +86,7 @@ async function readTransformBody(event) {
     body.set(chunk, offset);
     offset += chunk.byteLength;
   }
-  return new TextDecoder().decode(body);
+  return body;
 }
 export function withResponseBodyIdleTimeout(body, timeoutMs, onTimeout) {
   const reader = body.getReader();
@@ -145,6 +148,64 @@ function stripQueryFingerprinting(query, privacy) {
   }
   return { queryString: params.toString(), stripped };
 }
+function isUpstreamRedirect(status) {
+  return REDIRECT_STATUSES.has(status);
+}
+function upstreamFetchError(err, timedOut) {
+  const blockedPrivateNetwork = isPrivateNetworkResolutionError(err);
+  return createError({
+    statusCode: blockedPrivateNetwork ? 403 : timedOut ? 504 : 502,
+    statusMessage: blockedPrivateNetwork ? "Local network targets are not allowed" : timedOut ? "Gateway Timeout" : "Bad Gateway",
+    message: "Proxy upstream request failed",
+    cause: err,
+    data: {
+      errorName: err?.name,
+      errorCode: timedOut ? "TIMEOUT" : err?.code
+    }
+  });
+}
+function resolveProxyRedirect(response, state, redirectCount, urlAllowed) {
+  const location = response.headers.get("location");
+  if (!location) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Invalid upstream redirect",
+      message: "Upstream redirect has no Location header"
+    });
+  }
+  if (redirectCount >= MAX_UPSTREAM_REDIRECTS) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Too many upstream redirects",
+      message: "Upstream redirect limit exceeded"
+    });
+  }
+  let nextUrl;
+  try {
+    nextUrl = new URL(location, state.url);
+  } catch (cause) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Invalid upstream redirect",
+      message: "Upstream redirect URL is invalid",
+      cause
+    });
+  }
+  if (!urlAllowed(nextUrl)) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Unsafe upstream redirect",
+      message: `Upstream redirect target is not allowed: ${nextUrl.origin}`
+    });
+  }
+  const switchToGet = response.status === 303 && state.method !== "GET" && state.method !== "HEAD" || (response.status === 301 || response.status === 302) && state.method === "POST";
+  if (!switchToGet)
+    return { ...state, url: nextUrl };
+  const headers = { ...state.headers };
+  for (const header of REQUEST_BODY_HEADERS)
+    delete headers[header];
+  return { url: nextUrl, method: "GET", body: void 0, headers };
+}
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
   const proxyConfig = config["nuxt-scripts-proxy"];
@@ -282,12 +343,14 @@ export default defineEventHandler(async (event) => {
   }
   let body;
   let rawBody;
+  let rawBodyBytes;
   let passthroughBody = false;
   if (isWriteMethod) {
+    rawBodyBytes = await readBodyBytes(event);
     if (!shouldTransformBody) {
       passthroughBody = true;
     } else if (transformableBodyType === "form") {
-      const formBody = await readTransformBody(event);
+      const formBody = rawBodyBytes === void 0 ? void 0 : new TextDecoder().decode(rawBodyBytes);
       rawBody = formBody;
       if (formBody != null) {
         const params = new URLSearchParams(formBody);
@@ -315,7 +378,7 @@ export default defineEventHandler(async (event) => {
         body = transformed.toString();
       }
     } else {
-      const jsonBody = await readTransformBody(event);
+      const jsonBody = rawBodyBytes === void 0 ? void 0 : new TextDecoder().decode(rawBodyBytes);
       if (jsonBody !== void 0) {
         try {
           rawBody = JSON.parse(jsonBody);
@@ -365,55 +428,63 @@ export default defineEventHandler(async (event) => {
     controller.abort();
   }, UPSTREAM_TIMEOUT_MS);
   let fetchBody;
-  if (passthroughBody && originalHeaders["content-length"] !== "0") {
-    fetchBody = getRequestWebStream(event);
+  if (passthroughBody) {
+    if (rawBodyBytes && rawBodyBytes.byteLength > 0)
+      fetchBody = rawBodyBytes;
   } else if (body !== void 0) {
     fetchBody = transformableBodyType === "json" ? JSON.stringify(body) : String(body);
   }
+  const hopAllowed = (url) => url.protocol === "https:" && !url.username && !url.password && (!url.port || url.port === "443") && isPublicNetworkHostname(url.hostname) && Object.keys(domainPrivacy).some((configDomain) => matchDomain(url.hostname, configDomain));
   let response;
   let network;
   try {
     network = await createPublicNetworkDispatcher();
-    const requestInit = {
+    let state = {
+      url: new URL(targetUrl),
       method: method || "GET",
-      headers,
       body: fetchBody,
-      credentials: "omit",
-      // Don't send cookies to third parties
-      signal: controller.signal,
-      redirect: "manual",
-      duplex: fetchBody instanceof ReadableStream ? "half" : void 0
+      headers
     };
-    response = await network.fetch(targetUrl, requestInit);
+    for (let redirectCount = 0; ; redirectCount++) {
+      let hop;
+      try {
+        hop = await network.fetch(state.url.toString(), {
+          method: state.method,
+          headers: state.headers,
+          body: state.body,
+          credentials: "omit",
+          // Don't send cookies to third parties
+          signal: controller.signal,
+          redirect: "manual"
+        });
+      } catch (err) {
+        log("[proxy] Upstream error:", err);
+        throw upstreamFetchError(err, timedOut);
+      }
+      log("[proxy] Response:", hop.status, hop.statusText);
+      if (!isUpstreamRedirect(hop.status)) {
+        response = hop;
+        break;
+      }
+      let next;
+      try {
+        next = resolveProxyRedirect(hop, state, redirectCount, hopAllowed);
+      } catch (err) {
+        await hop.body?.cancel(err).catch((cancelError) => Object.assign(err, { cleanupError: cancelError }));
+        throw err;
+      }
+      const redirectDiscarded = new Error("Upstream redirect response body discarded");
+      await hop.body?.cancel(redirectDiscarded).catch((cancelError) => Object.assign(redirectDiscarded, { cause: cancelError }));
+      log("[proxy] Following redirect:", next.url.toString());
+      state = next;
+    }
     clearTimeout(timeoutId);
   } catch (err) {
     clearTimeout(timeoutId);
     await closePublicNetworkDispatcher(network, err);
-    log("[proxy] Upstream error:", err);
-    const blockedPrivateNetwork = isPrivateNetworkResolutionError(err);
-    throw createError({
-      statusCode: blockedPrivateNetwork ? 403 : timedOut ? 504 : 502,
-      statusMessage: blockedPrivateNetwork ? "Local network targets are not allowed" : timedOut ? "Gateway Timeout" : "Bad Gateway",
-      message: "Proxy upstream request failed",
-      cause: err,
-      data: {
-        errorName: err?.name,
-        errorCode: timedOut ? "TIMEOUT" : err?.code
-      }
-    });
-  }
-  log("[proxy] Response:", response.status, response.statusText);
-  if (response.status >= 300 && response.status < 400 && response.status !== 304) {
-    clearTimeout(timeoutId);
-    const redirectError = createError({
-      statusCode: 502,
-      statusMessage: "Unsafe upstream redirect",
-      message: "Proxy upstream returned a redirect that was not followed"
-    });
-    await response.body?.cancel(redirectError).catch((cancelError) => Object.assign(redirectError, { cleanupError: cancelError }));
-    await closePublicNetworkDispatcher(network, redirectError);
-    throw redirectError;
+    throw err;
   }
+  log("[proxy] Upstream settled:", response.status);
   const responseConnectionHeaders = new Set(
     (response.headers.get("connection") || "").split(",").map((header) => header.trim().toLowerCase()).filter(Boolean)
   );

package/dist/runtime/server/utils/network-dispatcher.platform.d.ts

@@ -1,2 +1,2 @@
-import type { CreateNetworkDispatcher } from './network-host.js';
-export declare const createNetworkDispatcher: CreateNetworkDispatcher;
+import type { PublicNetworkDispatcher } from './network-host.js';
+export declare const createNetworkDispatcher: () => Promise<PublicNetworkDispatcher>;

package/dist/runtime/server/utils/network-dispatcher.platform.js

@@ -1,5 +1,8 @@
 export const createNetworkDispatcher = async () => ({
-  fetch: globalThis.fetch,
+  // workerd's native fetch throws `TypeError: Illegal invocation` when a
+  // detached reference is called as a method (e.g. `dispatcher.fetch(...)`),
+  // so pin the receiver before handing the function to callers.
+  fetch: globalThis.fetch.bind(globalThis),
   close: async () => {
   }
 });

package/dist/runtime/types.d.ts

@@ -34,12 +34,14 @@ import type { NpmInput } from './registry/npm.js';
 import type { PayPalInput } from './registry/paypal.js';
 import type { PlausibleAnalyticsInput } from './registry/plausible-analytics.js';
 import type { PostHogInput } from './registry/posthog.js';
+import type { PulseAnalyticsInput } from './registry/pulse-analytics.js';
 import type { RedditPixelInput } from './registry/reddit-pixel.js';
 import type { RybbitAnalyticsInput } from './registry/rybbit-analytics.js';
 import type { SegmentInput } from './registry/segment.js';
 import type { SnapTrPixelInput } from './registry/snapchat-pixel.js';
 import type { SpeedCurveInput } from './registry/speedcurve.js';
 import type { StripeInput } from './registry/stripe.js';
+import type { TawkToInput } from './registry/tawk-to.js';
 import type { TikTokPixelInput } from './registry/tiktok-pixel.js';
 import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
 import type { UsercentricsInput } from './registry/usercentrics.js';
@@ -51,6 +53,7 @@ import type { YouTubePlayerInput } from './registry/youtube-player.js';
 import type { ProxyPrivacyInput } from './server/utils/privacy.js';
 export type { Cluster, ClusterStats, MarkerClustererContext, MarkerClustererInstance, MarkerClustererOptions } from './components/GoogleMaps/types.js';
 export { MARKER_CLUSTERER_INJECTION_KEY } from './components/GoogleMaps/types.js';
+export type { ScriptMapLibreGeoJsonEmits, ScriptMapLibreGeoJsonLayer, ScriptMapLibreGeoJsonProps, ScriptMapLibreGeoJsonResource, ScriptMapLibreMapEmits, ScriptMapLibreMapExpose, ScriptMapLibreMapProps, ScriptMapLibreMapSlots, ScriptMapLibreMarkerEmits, ScriptMapLibreMarkerProps, ScriptMapLibreNavigationControlProps, ScriptMapLibrePopupEmits, ScriptMapLibrePopupProps, } from './components/MapLibre/types.js';
 export type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
 /**
  * GCMv2 consent category value.
@@ -265,6 +268,7 @@ export interface ScriptRegistry {
     linkedinInsight?: LinkedInInsightInput;
     paypal?: PayPalInput;
     posthog?: PostHogInput;
+    pulseAnalytics?: PulseAnalyticsInput;
     matomoAnalytics?: MatomoAnalyticsInput;
     mixpanelAnalytics?: MixpanelAnalyticsInput;
     rybbitAnalytics?: RybbitAnalyticsInput;
@@ -272,6 +276,7 @@ export interface ScriptRegistry {
     segment?: SegmentInput;
     speedcurve?: SpeedCurveInput;
     stripe?: StripeInput;
+    tawkTo?: TawkToInput;
     tiktokPixel?: TikTokPixelInput;
     xEmbed?: XEmbedInput;
     xPixel?: XPixelInput;
@@ -289,7 +294,7 @@ export interface ScriptRegistry {
  * Built-in registry script keys — not affected by module augmentation.
  * Use this to type-check records that must enumerate all built-in scripts (logos, meta, etc.).
  */
-export type BuiltInRegistryScriptKey = 'ahrefsAnalytics' | 'bingUet' | 'blueskyEmbed' | 'calendly' | 'carbonAds' | 'crisp' | 'clarity' | 'cloudflareWebAnalytics' | 'databuddyAnalytics' | 'deskcrew' | 'metaPixel' | 'fathomAnalytics' | 'instagramEmbed' | 'plausibleAnalytics' | 'googleAdsense' | 'googleAnalytics' | 'googleMaps' | 'leaflet' | 'maplibre' | 'googleRecaptcha' | 'googleSignIn' | 'lemonSqueezy' | 'googleTagManager' | 'hotjar' | 'intercom' | 'linkedinInsight' | 'paypal' | 'posthog' | 'matomoAnalytics' | 'mixpanelAnalytics' | 'rybbitAnalytics' | 'redditPixel' | 'segment' | 'stripe' | 'tiktokPixel' | 'xEmbed' | 'xPixel' | 'snapchatPixel' | 'speedcurve' | 'youtubePlayer' | 'vercelAnalytics' | 'vimeoPlayer' | 'umamiAnalytics' | 'usercentrics' | 'gravatar' | 'npm';
+export type BuiltInRegistryScriptKey = 'ahrefsAnalytics' | 'bingUet' | 'blueskyEmbed' | 'calendly' | 'carbonAds' | 'crisp' | 'clarity' | 'cloudflareWebAnalytics' | 'databuddyAnalytics' | 'deskcrew' | 'metaPixel' | 'fathomAnalytics' | 'instagramEmbed' | 'plausibleAnalytics' | 'googleAdsense' | 'googleAnalytics' | 'googleMaps' | 'leaflet' | 'maplibre' | 'googleRecaptcha' | 'googleSignIn' | 'lemonSqueezy' | 'googleTagManager' | 'hotjar' | 'intercom' | 'linkedinInsight' | 'paypal' | 'posthog' | 'pulseAnalytics' | 'matomoAnalytics' | 'mixpanelAnalytics' | 'rybbitAnalytics' | 'redditPixel' | 'segment' | 'stripe' | 'tawkTo' | 'tiktokPixel' | 'xEmbed' | 'xPixel' | 'snapchatPixel' | 'speedcurve' | 'youtubePlayer' | 'vercelAnalytics' | 'vimeoPlayer' | 'umamiAnalytics' | 'usercentrics' | 'gravatar' | 'npm';
 /**
  * Union of all explicit registry script keys (excludes npm pattern).
  * Includes both built-in and augmented keys.