@analogjs/router 2.7.0-beta.1 → 2.7.0-beta.3

package/fesm2022/analogjs-router-server.mjs

@@ -1,10 +1,11 @@
-import { InjectionToken, Injector, runInInjectionContext, ɵresetCompiledComponents as _resetCompiledComponents, assertInInjectionContext, inject, TransferState, makeStateKey, reflectComponentType, APP_ID, ɵConsole as _Console, enableProdMode } from '@angular/core';
-import { ɵSERVER_CONTEXT as _SERVER_CONTEXT, provideServerRendering, renderApplication, platformServer } from '@angular/platform-server';
+import { InjectionToken, Injector, runInInjectionContext, ɵresetCompiledComponents as _resetCompiledComponents, enableProdMode } from '@angular/core';
+import { ɵSERVER_CONTEXT as _SERVER_CONTEXT, renderApplication, platformServer, INITIAL_CONFIG, ɵrenderInternal as _renderInternal, provideServerRendering } from '@angular/platform-server';
 import { REQUEST, RESPONSE, BASE_URL, LOCALE } from '@analogjs/router/tokens';
 import { SERVER_FN_DISPATCHER, createServerFnRef } from '@analogjs/router';
 import { HttpErrorResponse } from '@angular/common/http';
 import { bootstrapApplication, createApplication } from '@angular/platform-browser';
-import { getHeader, createEvent, readBody, eventHandler, getRouterParam } from 'h3';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { eventHandler, getRouterParam, readBody } from 'h3';
 
 /**
  * Server-side registry of server functions, keyed by id. A `.server.ts` module
@@ -392,145 +393,6 @@ function getRequestProtocol(req, opts = {}) {
     return req.connection?.encrypted ? 'https' : 'http';
 }
 
-const STATIC_PROPS = new InjectionToken('Static Props');
-function provideStaticProps(props) {
-    return {
-        provide: STATIC_PROPS,
-        useFactory() {
-            return props;
-        },
-    };
-}
-function injectStaticProps() {
-    assertInInjectionContext(injectStaticProps);
-    return inject(STATIC_PROPS);
-}
-function injectStaticOutputs() {
-    const transferState = inject(TransferState);
-    const outputsKey = makeStateKey('_analog_output');
-    return {
-        set(data) {
-            transferState.set(outputsKey, data);
-        },
-    };
-}
-
-function serverComponentRequest(serverContext) {
-    const serverComponentId = getHeader(createEvent(serverContext.req, serverContext.res), 'X-Analog-Component');
-    if (!serverComponentId &&
-        serverContext.req.url &&
-        serverContext.req.url.startsWith('/_analog/components')) {
-        const componentId = serverContext.req.url.split('/')?.[3];
-        return componentId;
-    }
-    return serverComponentId;
-}
-// Deferred so the module can be imported outside a Vite context (e.g. by the
-// Nitro server-function dispatch path, or tooling) without eagerly evaluating
-// the Vite-only `import.meta.glob` macro at load time. Vite still statically
-// rewrites the macro; it is just invoked lazily on first server-component render.
-let _components;
-function serverComponents() {
-    return (_components ??= import.meta.glob([
-        '/src/server/components/**/*.{ts,analog,ag}',
-    ]));
-}
-async function renderServerComponent(url, serverContext, config) {
-    const componentReqId = serverComponentRequest(serverContext);
-    const { componentLoader, componentId } = getComponentLoader(componentReqId);
-    if (!componentLoader) {
-        return new Response(`Server Component Not Found ${componentId}`, {
-            status: 404,
-        });
-    }
-    const component = (await componentLoader())['default'];
-    if (!component) {
-        return new Response(`No default export for ${componentId}`, {
-            status: 422,
-        });
-    }
-    const mirror = reflectComponentType(component);
-    const selector = mirror?.selector.split(',')?.[0] || 'server-component';
-    const event = createEvent(serverContext.req, serverContext.res);
-    const body = (await readBody(event)) || {};
-    const appId = `analog-server-${selector.toLowerCase()}-${new Date().getTime()}`;
-    const bootstrap = (context) => bootstrapApplication(component, {
-        providers: [
-            provideServerRendering(),
-            provideStaticProps(body),
-            { provide: _SERVER_CONTEXT, useValue: 'analog-server-component' },
-            {
-                provide: APP_ID,
-                useFactory() {
-                    return appId;
-                },
-            },
-            ...(config?.providers || []),
-        ],
-    }, context);
-    const html = await renderApplication(bootstrap, {
-        url,
-        document: `<${selector}></${selector}>`,
-        platformProviders: [
-            {
-                provide: _Console,
-                useFactory() {
-                    return {
-                        warn: () => { },
-                        log: () => { },
-                    };
-                },
-            },
-        ],
-    });
-    const outputs = retrieveTransferredState(html, appId);
-    const responseData = {
-        html,
-        outputs,
-    };
-    return new Response(JSON.stringify(responseData), {
-        headers: {
-            'X-Analog-Component': 'true',
-        },
-    });
-}
-function getComponentLoader(componentReqId) {
-    let _componentId = `/src/server/components/${componentReqId.toLowerCase()}`;
-    let componentLoader = undefined;
-    let componentId = _componentId;
-    const components = serverComponents();
-    if (components[`${_componentId}.ts`]) {
-        componentId = `${_componentId}.ts`;
-        componentLoader = components[componentId];
-    }
-    return { componentLoader, componentId };
-}
-function retrieveTransferredState(html, appId) {
-    const regex = new RegExp(`<script id="${appId}-state" type="application/json">(.*?)<\/script>`);
-    const match = html.match(regex);
-    if (match) {
-        const scriptContent = match[1];
-        if (scriptContent) {
-            try {
-                const parsedContent = JSON.parse(scriptContent);
-                return parsedContent._analog_output || {};
-            }
-            catch (e) {
-                console.warn('Exception while parsing static outputs for ' + appId, e);
-            }
-        }
-        return {};
-    }
-    else {
-        return {};
-    }
-}
-
-// Optional chaining: the server-function dispatch endpoint imports this entry
-// from a Nitro bundle, where `import.meta.env` is not defined at all.
-if (import.meta.env?.PROD) {
-    enableProdMode();
-}
 /**
  * Nulls `def.tView` on every component definition that Angular has
  * compiled in this process. Angular caches the result of `consts()` on
@@ -552,6 +414,12 @@ function resetComponentDefTViews() {
         def.tView = null;
     }
 }
+
+// Optional chaining: the server-function dispatch endpoint imports this entry
+// from a Nitro bundle, where `import.meta.env` is not defined at all.
+if (import.meta.env?.PROD) {
+    enableProdMode();
+}
 /**
  * Returns a function that accepts the navigation URL,
  * the root HTML, and server context.
@@ -566,9 +434,6 @@ function render(rootComponent, config, platformProviders = []) {
         return bootstrapApplication(rootComponent, config, context);
     }
     return async function render(url, document, serverContext) {
-        if (serverComponentRequest(serverContext)) {
-            return await renderServerComponent(url, serverContext);
-        }
         resetComponentDefTViews();
         const html = await renderApplication(bootstrap, {
             document,
@@ -582,6 +447,385 @@ function render(rootComponent, config, platformProviders = []) {
     };
 }
 
+/**
+ * Pure string helpers for slicing a fully rendered SSR document into the parts
+ * the streaming renderer flushes: the shell up to `<body>`, the authoritative
+ * `<body>` inner HTML for the tail, and the authoritative `<head>` inner HTML
+ * for the finalize-time head reconcile. Extracted from `render-stream` so they
+ * can be unit tested without driving the platform.
+ */
+/** Byte offset just after the opening `<body>` tag, or 0 if none. */
+function afterBodyOpen(html) {
+    const m = /<body[^>]*>/i.exec(html);
+    return m ? m.index + m[0].length : 0;
+}
+/** Inner HTML of `<body>` from a fully rendered document string. */
+function bodyInner(html) {
+    const start = afterBodyOpen(html);
+    const end = html.lastIndexOf('</body>');
+    return html.slice(start, end > -1 ? end : html.length);
+}
+/** Inner HTML of `<head>` from a fully rendered document string. */
+function headInner(html) {
+    const open = /<head[^>]*>/i.exec(html);
+    if (!open)
+        return '';
+    const start = open.index + open[0].length;
+    const end = html.indexOf('</head>', start);
+    return html.slice(start, end > -1 ? end : start);
+}
+
+/**
+ * Per-request decisions about whether the streaming renderer should fall back
+ * to a buffered render. Extracted from `render-stream` so they can be unit
+ * tested without driving the platform.
+ */
+/**
+ * User agents that receive a fully buffered render (with a resolved `<head>`)
+ * instead of the streamed shell. Streaming flushes the head before the app has
+ * set a dynamic title/meta and reconciles it via a finalize script; a crawler
+ * that does not run that script would index the shell's static head. Mirrors
+ * Nuxt's bot bypass — streaming targets interactive clients, bots get the
+ * buffered path whose head is byte-identical to the classic `render()`.
+ */
+const SSR_BOT_RE = /bot|crawl|spider|slurp|mediapartners|facebookexternalhit|embedly|quora link preview|outbrain|pinterest|vkshare|w3c_validator|whatsapp|telegrambot|lighthouse|google-inspectiontool|headlesschrome|bingpreview/i;
+function isLikelyBot(serverContext) {
+    const ua = serverContext?.req?.headers?.['user-agent'];
+    return typeof ua === 'string' && SSR_BOT_RE.test(ua);
+}
+/**
+ * Whether streaming is disabled for this request by a `streaming: false` route
+ * rule. The platform plugin translates that rule into an `x-analog-no-streaming`
+ * response header (mirroring how `ssr: false` becomes `x-analog-no-ssr`); when
+ * present, `renderStream` produces the buffered `render()` output for this
+ * route instead of streaming.
+ */
+function streamingDisabledByRoute(serverContext) {
+    return serverContext?.res?.getHeader?.('x-analog-no-streaming') === 'true';
+}
+
+/**
+ * Tiny client runtime for progressive streaming SSR — EXPERIMENTAL.
+ *
+ * `renderStream` streams the document in three parts:
+ *   1. the head + this runtime + an empty `<div data-analog-stream>` region;
+ *   2. each `@defer` block, as it resolves on the server, as a
+ *      `<template data-analog-defer="ID">…</template>` followed by a call to
+ *      `window.__analogPaint("ID")` — this runtime paints the block into the
+ *      streaming region immediately, so content appears progressively and out
+ *      of document order;
+ *   3. the authoritative document tail: the app's resolved `<head>` in a
+ *      `<template data-analog-head>` and the hydration-annotated body in a
+ *      `<template data-analog-authoritative>`, followed by
+ *      `window.__analogReconcileHead()` + `window.__analogFinalize()`. The head
+ *      is reconciled first (a dynamically-set `<title>`/meta is applied to the
+ *      live document, since the streamed shell head was flushed before the app
+ *      ran), then the body is swapped to the exact document Angular's
+ *      incremental hydration expects.
+ *
+ * Emitted into the document by `renderStream`. Exported as a string so it can
+ * be injected verbatim and unit-tested against a DOM.
+ */
+const DEFER_RECONCILE_RUNTIME = /* js */ `
+(function () {
+  function region() {
+    return document.querySelector('[data-analog-stream]');
+  }
+  window.__analogPaint = function (id) {
+    var tpl = document.querySelector('template[data-analog-defer="' + id + '"]');
+    var r = region();
+    if (!tpl || !r) return;
+    r.appendChild(tpl.content.cloneNode(true));
+    tpl.remove();
+  };
+  window.__analogReconcileHead = function () {
+    // The shell head was flushed before the app rendered, so any title/meta the
+    // app set during render (Title/Meta services, route meta) is missing from
+    // the live document. Apply the authoritative head here, before hydration —
+    // matching how a buffered render would have produced the head. Idempotent:
+    // tags already present (charset, viewport, stylesheet/preload links) are
+    // matched and left as-is; only changed/added ones are updated.
+    var tpl = document.querySelector('template[data-analog-head]');
+    if (!tpl) return;
+    var frag = tpl.content;
+    var head = document.head;
+    var title = frag.querySelector('title');
+    if (title) document.title = title.textContent || '';
+    function metaKey(m) {
+      if (m.hasAttribute('charset')) return 'charset';
+      var attrs = ['name', 'property', 'http-equiv', 'itemprop'];
+      for (var i = 0; i < attrs.length; i++) {
+        if (m.hasAttribute(attrs[i])) return attrs[i] + '=' + m.getAttribute(attrs[i]);
+      }
+      return null;
+    }
+    var existingMeta = {};
+    var metas = head.querySelectorAll('meta');
+    for (var i = 0; i < metas.length; i++) {
+      var k = metaKey(metas[i]);
+      if (k) existingMeta[k] = metas[i];
+    }
+    frag.querySelectorAll('meta').forEach(function (m) {
+      var key = metaKey(m);
+      if (key == null) return;
+      if (existingMeta[key]) existingMeta[key].replaceWith(m.cloneNode(true));
+      else head.appendChild(m.cloneNode(true));
+    });
+    var existingHref = {};
+    var links = head.querySelectorAll('link[href]');
+    for (var j = 0; j < links.length; j++) {
+      existingHref[links[j].getAttribute('href')] = true;
+    }
+    frag.querySelectorAll('link').forEach(function (l) {
+      var href = l.getAttribute('href');
+      if (href && existingHref[href]) return;
+      head.appendChild(l.cloneNode(true));
+      if (href) existingHref[href] = true;
+    });
+    tpl.remove();
+  };
+  window.__analogFinalize = function () {
+    var auth = document.querySelector('template[data-analog-authoritative]');
+    if (!auth) return;
+    // Replace the entire body — preview region, block templates and runtime
+    // scripts — with just the authoritative body, so the reconciled DOM matches
+    // a buffered render byte-for-byte before hydration boots.
+    document.body.replaceChildren(auth.content.cloneNode(true));
+  };
+})();
+`;
+
+/**
+ * Progressive streaming SSR renderer — EXPERIMENTAL.
+ *
+ * Returns a `ReadableStream<Uint8Array>` that flushes bytes DURING the render,
+ * not after it:
+ *   1. the document head + a client reconcile runtime are flushed immediately,
+ *      before the app has finished rendering, so the browser starts fetching
+ *      assets right away;
+ *   2. each `@defer (hydrate …)` block's content is flushed the moment it
+ *      resolves on the server — out of document order — while later blocks are
+ *      still pending (proven: a slow block does not hold back an early one);
+ *   3. once the app is stable, the authoritative, fully hydration-annotated
+ *      document is flushed as the tail. This is byte-identical to a buffered
+ *      `renderApplication`, and is what Angular's incremental hydration runs
+ *      against on the client.
+ *
+ * Unlike a buffered renderer, this drives the platform directly
+ * (`platformServer` + `bootstrapApplication` + `ɵrenderInternal`) so it can
+ * interleave flushes with rendering. Angular's hydration annotation is
+ * whole-document (the root's `ngh` index references every `@defer` container),
+ * so the authoritative hydration payload is necessarily the tail: RENDERING
+ * streams progressively, and hydration begins once the tail arrives.
+ *
+ * Depends on an upstream Angular per-block resolution hook exposed on two
+ * globals (see {@link SsrStreamingGlobals}). When the primitive is absent,
+ * `renderStream` degrades to a single buffered chunk so behaviour matches the
+ * classic `render()` path, which is unchanged and remains the default.
+ */
+if (import.meta.env.PROD) {
+    enableProdMode();
+}
+function streamingPrimitiveAvailable() {
+    const g = globalThis;
+    return (typeof g.__analogSsrInternals?.collectNativeNodesInLContainer === 'function');
+}
+/**
+ * Per-render capture handlers live in async-local storage, not a single shared
+ * global slot, so concurrent renders in one process do not clobber each other.
+ * `globalThis.__analogSsrDeferCapture` is a stable dispatcher installed once; it
+ * routes each resolved `@defer` block to the handler of the render whose async
+ * context it fired in. A block that resolves outside any render (no store) is a
+ * no-op.
+ */
+const captureStore = new AsyncLocalStorage();
+function installCaptureDispatcher() {
+    const g = globalThis;
+    if (g.__analogSsrDeferCapture?.__analogDispatcher)
+        return;
+    const dispatch = ((ev) => {
+        captureStore.getStore()?.(ev);
+    });
+    dispatch.__analogDispatcher = true;
+    g.__analogSsrDeferCapture = dispatch;
+}
+let warnedMissingPrimitive = false;
+function warnMissingPrimitiveOnce() {
+    if (warnedMissingPrimitive || !import.meta.env.DEV)
+        return;
+    warnedMissingPrimitive = true;
+    console.warn('[@analogjs/router] renderStream: the streaming hook was not found on ' +
+        '@angular/core, so rendering falls back to buffered. Enable ' +
+        '`experimental.streaming` in your Analog config; if it already is, your ' +
+        'installed Angular version may be incompatible with the streaming patch.');
+}
+/**
+ * Serialize a `@defer` block's live domino subtree to HTML. Called a macrotask
+ * after the block resolves, by which point change detection has filled in the
+ * block's interpolations.
+ */
+function serializeLContainerHtml(lContainer) {
+    const g = globalThis;
+    const collect = g.__analogSsrInternals?.collectNativeNodesInLContainer;
+    if (!collect)
+        return '';
+    const nodes = [];
+    collect(lContainer, nodes);
+    let html = '';
+    for (const n of nodes)
+        html += n?.outerHTML ?? n?.data ?? n?.nodeValue ?? '';
+    return html;
+}
+/** Destroy the platform on a macrotask, matching `renderApplication`. */
+function asyncDestroyPlatform(platformRef) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            platformRef.destroy();
+            resolve();
+        }, 0);
+    });
+}
+/**
+ * Returns a function that renders a URL to a `ReadableStream<Uint8Array>`.
+ *
+ * Usage in main.server.ts:
+ * ```ts
+ * import { renderStream } from '@analogjs/router/server';
+ * export default renderStream(App, config);
+ * ```
+ */
+function renderStream(rootComponent, config, platformProviders = []) {
+    function bootstrap(context) {
+        return bootstrapApplication(rootComponent, config, context);
+    }
+    return async function renderStream(url, document, serverContext) {
+        // Reset before every render — both the buffered fallback below and the
+        // streaming path — so a prior render's locale/consts are not frozen for the
+        // process lifetime (parity with render.ts).
+        resetComponentDefTViews();
+        // Fall back to a single buffered chunk so output matches the classic path
+        // for:
+        //   - crawlers, which may not run the finalize script that reconciles a
+        //     dynamic <head>, so they get a buffered render with a resolved head;
+        //   - routes with a `streaming: false` rule (opt out per route);
+        //   - a missing streaming primitive.
+        const primitiveAvailable = streamingPrimitiveAvailable();
+        const bot = isLikelyBot(serverContext);
+        const routeDisabled = streamingDisabledByRoute(serverContext);
+        if (bot || routeDisabled || !primitiveAvailable) {
+            // Warn only when the primitive is genuinely absent — the bot and
+            // route-opt-out paths fall back to buffered by design, not by degradation.
+            if (!bot && !routeDisabled && !primitiveAvailable) {
+                warnMissingPrimitiveOnce();
+            }
+            const html = await renderApplication((context) => bootstrapApplication(rootComponent, config, context), {
+                document,
+                url,
+                platformProviders: [
+                    provideServerContext(serverContext),
+                    platformProviders,
+                ],
+            });
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new TextEncoder().encode(html));
+                    controller.close();
+                },
+            });
+        }
+        installCaptureDispatcher();
+        const encoder = new TextEncoder();
+        // The stream is returned immediately; `start` fills it as the render
+        // progresses, so the consumer receives the head, then each @defer block the
+        // moment it resolves, then the authoritative tail — true streaming.
+        return new ReadableStream({
+            async start(controller) {
+                const enqueue = (s) => controller.enqueue(encoder.encode(s));
+                // The capture handler fires once per @defer block as it resolves. The
+                // block's DOM is not filled until the next change-detection tick, so we
+                // serialize + flush it a macrotask later — flushing DURING the render.
+                // It is scoped to this render via async-local storage (see
+                // installCaptureDispatcher) so concurrent renders never cross-talk.
+                let blockIndex = 0;
+                let capturing = true;
+                const seen = new Set();
+                const pendingFlushes = [];
+                const onBlockResolved = (ev) => {
+                    // A block can reach `Complete` more than once during a render; only
+                    // stream each container once. Also ignore any resolution that fires
+                    // after the render has moved on to serializing the authoritative tail.
+                    if (!capturing || seen.has(ev.lContainer))
+                        return;
+                    seen.add(ev.lContainer);
+                    const id = `s${blockIndex++}`;
+                    pendingFlushes.push(new Promise((resolve) => {
+                        setTimeout(() => {
+                            const html = serializeLContainerHtml(ev.lContainer);
+                            enqueue(`<template data-analog-defer="${id}">${html}</template>` +
+                                `<script>window.__analogPaint&&window.__analogPaint(${JSON.stringify(id)})</script>`);
+                            resolve();
+                        }, 0);
+                    }));
+                };
+                // Run the whole render inside the async-local context so every
+                // change-detection tick and @defer resolution it schedules routes back
+                // to THIS render's handler.
+                await captureStore.run(onBlockResolved, async () => {
+                    const platformRef = platformServer([
+                        { provide: INITIAL_CONFIG, useValue: { document, url } },
+                        provideServerContext(serverContext),
+                        platformProviders,
+                    ]);
+                    // 1. Flush the head + reconcile runtime immediately (before the app is
+                    //    rendered), then open the live streaming region.
+                    enqueue(document.slice(0, afterBodyOpen(document)) +
+                        `<script>${DEFER_RECONCILE_RUNTIME}</script>` +
+                        `<div data-analog-stream></div>`);
+                    let appRef;
+                    let errored = false;
+                    try {
+                        // 2. Bootstrap + render. Blocks resolve out of order during this
+                        //    phase and flush via the capture handler above.
+                        appRef = await bootstrap({ platformRef });
+                        await appRef.whenStable();
+                        await Promise.all(pendingFlushes);
+                        // Stop capturing before serializing the tail so late resolutions
+                        // triggered by the hydration pass are not streamed as extra blocks.
+                        capturing = false;
+                        // 3. Flush the authoritative, fully hydration-annotated document as
+                        //    the tail. Carried in <template>s (their inert `ng-state`
+                        //    script survives). The app's resolved <head> ships alongside so
+                        //    a dynamically-set title/meta — set during render, after the
+                        //    shell head was already flushed — is reconciled onto the live
+                        //    document before the runtime swaps in the body and hydration
+                        //    boots.
+                        const authoritative = await _renderInternal(platformRef, appRef);
+                        enqueue(`<template data-analog-head>${headInner(authoritative)}</template>` +
+                            `<template data-analog-authoritative>${bodyInner(authoritative)}</template>` +
+                            `<script>window.__analogReconcileHead&&window.__analogReconcileHead();` +
+                            `window.__analogFinalize&&window.__analogFinalize()</script>` +
+                            `</body></html>`);
+                    }
+                    catch (err) {
+                        // The head + runtime were already flushed, so the status/headers are
+                        // committed; error the stream (a no-op silent close would hand the
+                        // client a truncated, non-hydratable 200) and log with block context.
+                        errored = true;
+                        console.error(`[@analogjs/router] renderStream failed for ${url} after ` +
+                            `${blockIndex} block(s); response truncated.`, err);
+                        controller.error(err);
+                    }
+                    finally {
+                        await asyncDestroyPlatform(platformRef);
+                        if (!errored)
+                            controller.close();
+                    }
+                });
+            },
+        });
+    };
+}
+
 function serverFn(arg1, arg2) {
     const { config, handler } = normalizeArgs(arg1, arg2);
     // GET is reserved for input-less reads; an input schema requires POST (the
@@ -715,5 +959,5 @@ async function handleServerFnRequest(event, appInjector) {
  * Generated bundle index. Do not edit.
  */
 
-export { SERVER_FN_ALLOWED_ORIGINS, SERVER_FN_INTERCEPTORS, createServerFnAppInjector, createServerFnEventHandler, dispatchServerFn, handleServerFnRequest, injectStaticOutputs, injectStaticProps, isServerFnOriginAllowed, provideServerContext, provideServerFns, render, renderServerComponent, runInterceptors, serverComponentRequest, serverFn, serverFnRegistry, withAllowedOrigins, withServerFnInterceptors };
+export { SERVER_FN_ALLOWED_ORIGINS, SERVER_FN_INTERCEPTORS, createServerFnAppInjector, createServerFnEventHandler, dispatchServerFn, handleServerFnRequest, isServerFnOriginAllowed, provideServerContext, provideServerFns, render, renderStream, runInterceptors, serverFn, serverFnRegistry, withAllowedOrigins, withServerFnInterceptors };
 //# sourceMappingURL=analogjs-router-server.mjs.map