astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/core/app/base.js

@@ -0,0 +1,448 @@
+import {
+  appendForwardSlash,
+  collapseDuplicateTrailingSlashes,
+  hasFileExtension,
+  isInternalPath,
+  joinPaths,
+  prependForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { matchPattern } from "../../assets/utils/index.js";
+import { normalizeTheLocale } from "../../i18n/index.js";
+import {
+  clientAddressSymbol,
+  DEFAULT_404_COMPONENT,
+  REROUTABLE_STATUS_CODES,
+  REROUTE_DIRECTIVE_HEADER,
+  responseSentSymbol
+} from "../constants.js";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { consoleLogDestination } from "../logger/console.js";
+import { AstroIntegrationLogger, Logger } from "../logger/core.js";
+import { RenderContext } from "../render-context.js";
+import { redirectTemplate } from "../routing/3xx.js";
+import { ensure404Route } from "../routing/astro-designed-error-pages.js";
+import { matchRoute } from "../routing/match.js";
+import { PERSIST_SYMBOL } from "../session.js";
+class BaseApp {
+  manifest;
+  manifestData;
+  pipeline;
+  adapterLogger;
+  baseWithoutTrailingSlash;
+  logger;
+  constructor(manifest, streaming = true, ...args) {
+    this.manifest = manifest;
+    this.manifestData = { routes: manifest.routes.map((route) => route.routeData) };
+    this.baseWithoutTrailingSlash = removeTrailingForwardSlash(manifest.base);
+    this.pipeline = this.createPipeline(streaming, manifest, ...args);
+    this.logger = new Logger({
+      dest: consoleLogDestination,
+      level: manifest.logLevel
+    });
+    this.adapterLogger = new AstroIntegrationLogger(this.logger.options, manifest.adapterName);
+    ensure404Route(this.manifestData);
+  }
+  async createRenderContext(payload) {
+    return RenderContext.create(payload);
+  }
+  getAdapterLogger() {
+    return this.adapterLogger;
+  }
+  getAllowedDomains() {
+    return this.manifest.allowedDomains;
+  }
+  matchesAllowedDomains(forwardedHost, protocol) {
+    return BaseApp.validateForwardedHost(forwardedHost, this.manifest.allowedDomains, protocol);
+  }
+  static validateForwardedHost(forwardedHost, allowedDomains, protocol) {
+    if (!allowedDomains || allowedDomains.length === 0) {
+      return false;
+    }
+    try {
+      const testUrl = new URL(`${protocol || "https"}://${forwardedHost}`);
+      return allowedDomains.some((pattern) => {
+        return matchPattern(testUrl, pattern);
+      });
+    } catch {
+      return false;
+    }
+  }
+  set setManifestData(newManifestData) {
+    this.manifestData = newManifestData;
+  }
+  removeBase(pathname) {
+    if (pathname.startsWith(this.manifest.base)) {
+      return pathname.slice(this.baseWithoutTrailingSlash.length + 1);
+    }
+    return pathname;
+  }
+  /**
+   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
+   *
+   * If the decoding fails, it logs the error and return the pathname as is.
+   * @param request
+   */
+  getPathnameFromRequest(request) {
+    const url = new URL(request.url);
+    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+    try {
+      return decodeURI(pathname);
+    } catch (e) {
+      this.getAdapterLogger().error(e.toString());
+      return pathname;
+    }
+  }
+  /**
+   * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
+   * routes aren't returned, even if they are matched.
+   *
+   * When `allowPrerenderedRoutes` is `true`, the function returns matched prerendered routes too.
+   * @param request
+   * @param allowPrerenderedRoutes
+   */
+  match(request, allowPrerenderedRoutes = false) {
+    const url = new URL(request.url);
+    if (this.manifest.assets.has(url.pathname)) return void 0;
+    let pathname = this.computePathnameFromDomain(request);
+    if (!pathname) {
+      pathname = prependForwardSlash(this.removeBase(url.pathname));
+    }
+    let routeData = matchRoute(decodeURI(pathname), this.manifestData);
+    if (!routeData) return void 0;
+    if (allowPrerenderedRoutes) {
+      return routeData;
+    } else if (routeData.prerender) {
+      return void 0;
+    }
+    return routeData;
+  }
+  computePathnameFromDomain(request) {
+    let pathname = void 0;
+    const url = new URL(request.url);
+    if (this.manifest.i18n && (this.manifest.i18n.strategy === "domains-prefix-always" || this.manifest.i18n.strategy === "domains-prefix-other-locales" || this.manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
+      let host = request.headers.get("X-Forwarded-Host");
+      let protocol = request.headers.get("X-Forwarded-Proto");
+      if (protocol) {
+        protocol = protocol + ":";
+      } else {
+        protocol = url.protocol;
+      }
+      if (!host) {
+        host = request.headers.get("Host");
+      }
+      if (host && protocol) {
+        host = host.split(":")[0];
+        try {
+          let locale;
+          const hostAsUrl = new URL(`${protocol}//${host}`);
+          for (const [domainKey, localeValue] of Object.entries(
+            this.manifest.i18n.domainLookupTable
+          )) {
+            const domainKeyAsUrl = new URL(domainKey);
+            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
+              locale = localeValue;
+              break;
+            }
+          }
+          if (locale) {
+            pathname = prependForwardSlash(
+              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
+            );
+            if (url.pathname.endsWith("/")) {
+              pathname = appendForwardSlash(pathname);
+            }
+          }
+        } catch (e) {
+          this.logger.error(
+            "router",
+            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
+          );
+          this.logger.error("router", `Error: ${e}`);
+        }
+      }
+    }
+    return pathname;
+  }
+  redirectTrailingSlash(pathname) {
+    const { trailingSlash } = this.manifest;
+    if (pathname === "/" || isInternalPath(pathname)) {
+      return pathname;
+    }
+    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
+    if (path !== pathname) {
+      return path;
+    }
+    if (trailingSlash === "ignore") {
+      return pathname;
+    }
+    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
+      return appendForwardSlash(pathname);
+    }
+    if (trailingSlash === "never") {
+      return removeTrailingForwardSlash(pathname);
+    }
+    return pathname;
+  }
+  async render(request, renderOptions) {
+    let routeData = renderOptions?.routeData;
+    let locals;
+    let clientAddress;
+    let addCookieHeader;
+    const url = new URL(request.url);
+    const redirect = this.redirectTrailingSlash(url.pathname);
+    const prerenderedErrorPageFetch = renderOptions?.prerenderedErrorPageFetch ?? fetch;
+    if (redirect !== url.pathname) {
+      const status = request.method === "GET" ? 301 : 308;
+      return new Response(
+        redirectTemplate({
+          status,
+          relativeLocation: url.pathname,
+          absoluteLocation: redirect,
+          from: request.url
+        }),
+        {
+          status,
+          headers: {
+            location: redirect + url.search
+          }
+        }
+      );
+    }
+    addCookieHeader = renderOptions?.addCookieHeader;
+    clientAddress = renderOptions?.clientAddress ?? Reflect.get(request, clientAddressSymbol);
+    routeData = renderOptions?.routeData;
+    locals = renderOptions?.locals;
+    if (routeData) {
+      this.logger.debug(
+        "router",
+        "The adapter " + this.manifest.adapterName + " provided a custom RouteData for ",
+        request.url
+      );
+      this.logger.debug("router", "RouteData:\n" + routeData);
+    }
+    if (locals) {
+      if (typeof locals !== "object") {
+        const error = new AstroError(AstroErrorData.LocalsNotAnObject);
+        this.logger.error(null, error.stack);
+        return this.renderError(request, {
+          status: 500,
+          error,
+          clientAddress,
+          prerenderedErrorPageFetch
+        });
+      }
+    }
+    if (!routeData) {
+      routeData = this.match(request);
+      this.logger.debug("router", "Astro matched the following route for " + request.url);
+      this.logger.debug("router", "RouteData:\n" + routeData);
+    }
+    if (!routeData) {
+      routeData = this.manifestData.routes.find(
+        (route) => route.component === "404.astro" || route.component === DEFAULT_404_COMPONENT
+      );
+    }
+    if (!routeData) {
+      this.logger.debug("router", "Astro hasn't found routes that match " + request.url);
+      this.logger.debug("router", "Here's the available routes:\n", this.manifestData);
+      return this.renderError(request, {
+        locals,
+        status: 404,
+        clientAddress,
+        prerenderedErrorPageFetch
+      });
+    }
+    const pathname = this.getPathnameFromRequest(request);
+    const defaultStatus = this.getDefaultStatusCode(routeData, pathname);
+    let response;
+    let session;
+    try {
+      const componentInstance = await this.pipeline.getComponentByRoute(routeData);
+      const renderContext = await this.createRenderContext({
+        pipeline: this.pipeline,
+        locals,
+        pathname,
+        request,
+        routeData,
+        status: defaultStatus,
+        clientAddress
+      });
+      session = renderContext.session;
+      response = await renderContext.render(componentInstance);
+    } catch (err) {
+      this.logger.error(null, err.stack || err.message || String(err));
+      return this.renderError(request, {
+        locals,
+        status: 500,
+        error: err,
+        clientAddress,
+        prerenderedErrorPageFetch
+      });
+    } finally {
+      await session?.[PERSIST_SYMBOL]();
+    }
+    if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
+    // but uses the current route to handle the 404
+    response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+      return this.renderError(request, {
+        locals,
+        response,
+        status: response.status,
+        // We don't have an error to report here. Passing null means we pass nothing intentionally
+        // while undefined means there's no error
+        error: response.status === 500 ? null : void 0,
+        clientAddress,
+        prerenderedErrorPageFetch
+      });
+    }
+    if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
+      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+    }
+    if (addCookieHeader) {
+      for (const setCookieHeaderValue of BaseApp.getSetCookieFromResponse(response)) {
+        response.headers.append("set-cookie", setCookieHeaderValue);
+      }
+    }
+    Reflect.set(response, responseSentSymbol, true);
+    return response;
+  }
+  setCookieHeaders(response) {
+    return getSetCookiesFromResponse(response);
+  }
+  /**
+   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
+   * For example,
+   * ```ts
+   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
+   *     const cookie: string = cookie_
+   * }
+   * ```
+   * @param response The response to read cookies from.
+   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
+   */
+  static getSetCookieFromResponse = getSetCookiesFromResponse;
+  /**
+   * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
+   * This also handles pre-rendered /404 or /500 routes
+   */
+  async renderError(request, {
+    locals,
+    status,
+    response: originalResponse,
+    skipMiddleware = false,
+    error,
+    clientAddress,
+    prerenderedErrorPageFetch
+  }) {
+    const errorRoutePath = `/${status}${this.manifest.trailingSlash === "always" ? "/" : ""}`;
+    const errorRouteData = matchRoute(errorRoutePath, this.manifestData);
+    const url = new URL(request.url);
+    if (errorRouteData) {
+      if (errorRouteData.prerender) {
+        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
+        const statusURL = new URL(`${this.baseWithoutTrailingSlash}/${status}${maybeDotHtml}`, url);
+        if (statusURL.toString() !== request.url && prerenderedErrorPageFetch) {
+          const response2 = await prerenderedErrorPageFetch(statusURL.toString());
+          const override = { status, removeContentEncodingHeaders: true };
+          return this.mergeResponses(response2, originalResponse, override);
+        }
+      }
+      const mod = await this.pipeline.getComponentByRoute(errorRouteData);
+      let session;
+      try {
+        const renderContext = await this.createRenderContext({
+          locals,
+          pipeline: this.pipeline,
+          skipMiddleware,
+          pathname: this.getPathnameFromRequest(request),
+          request,
+          routeData: errorRouteData,
+          status,
+          props: { error },
+          clientAddress
+        });
+        session = renderContext.session;
+        const response2 = await renderContext.render(mod);
+        return this.mergeResponses(response2, originalResponse);
+      } catch {
+        if (skipMiddleware === false) {
+          return this.renderError(request, {
+            locals,
+            status,
+            response: originalResponse,
+            skipMiddleware: true,
+            clientAddress,
+            prerenderedErrorPageFetch
+          });
+        }
+      } finally {
+        await session?.[PERSIST_SYMBOL]();
+      }
+    }
+    const response = this.mergeResponses(new Response(null, { status }), originalResponse);
+    Reflect.set(response, responseSentSymbol, true);
+    return response;
+  }
+  mergeResponses(newResponse, originalResponse, override) {
+    let newResponseHeaders = newResponse.headers;
+    if (override?.removeContentEncodingHeaders) {
+      newResponseHeaders = new Headers(newResponseHeaders);
+      newResponseHeaders.delete("Content-Encoding");
+      newResponseHeaders.delete("Content-Length");
+    }
+    if (!originalResponse) {
+      if (override !== void 0) {
+        return new Response(newResponse.body, {
+          status: override.status,
+          statusText: newResponse.statusText,
+          headers: newResponseHeaders
+        });
+      }
+      return newResponse;
+    }
+    const status = override?.status ? override.status : originalResponse.status === 200 ? newResponse.status : originalResponse.status;
+    try {
+      originalResponse.headers.delete("Content-type");
+    } catch {
+    }
+    const mergedHeaders = new Map([
+      ...Array.from(newResponseHeaders),
+      ...Array.from(originalResponse.headers)
+    ]);
+    const newHeaders = new Headers();
+    for (const [name, value] of mergedHeaders) {
+      newHeaders.set(name, value);
+    }
+    return new Response(newResponse.body, {
+      status,
+      statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
+      // If you're looking at here for possible bugs, it means that it's not a bug.
+      // With the middleware, users can meddle with headers, and we should pass to the 404/500.
+      // If users see something weird, it's because they are setting some headers they should not.
+      //
+      // Although, we don't want it to replace the content-type, because the error page must return `text/html`
+      headers: newHeaders
+    });
+  }
+  getDefaultStatusCode(routeData, pathname) {
+    if (!routeData.pattern.test(pathname)) {
+      for (const fallbackRoute of routeData.fallbackRoutes) {
+        if (fallbackRoute.pattern.test(pathname)) {
+          return 302;
+        }
+      }
+    }
+    const route = removeTrailingForwardSlash(routeData.route);
+    if (route.endsWith("/404")) return 404;
+    if (route.endsWith("/500")) return 500;
+    return 200;
+  }
+  getManifest() {
+    return this.pipeline.manifest;
+  }
+}
+export {
+  BaseApp
+};

package/dist/core/app/common.d.ts

@@ -1,2 +1,6 @@
-import type { SerializedSSRManifest, SSRManifest } from './types.js';
-export declare function deserializeManifest(serializedManifest: SerializedSSRManifest): SSRManifest;
+import type { AstroConfig } from '../../types/public/index.js';
+import type { SSRManifest } from './types.js';
+export type RoutingStrategies = 'manual' | 'pathname-prefix-always' | 'pathname-prefix-other-locales' | 'pathname-prefix-always-no-redirect' | 'domains-prefix-always' | 'domains-prefix-other-locales' | 'domains-prefix-always-no-redirect';
+export declare function toRoutingStrategy(routing: NonNullable<AstroConfig['i18n']>['routing'], domains: NonNullable<AstroConfig['i18n']>['domains']): RoutingStrategies;
+export declare function toFallbackType(routing: NonNullable<AstroConfig['i18n']>['routing']): 'redirect' | 'rewrite';
+export declare function fromRoutingStrategy(strategy: RoutingStrategies, fallbackType: NonNullable<SSRManifest['i18n']>['fallbackType']): NonNullable<AstroConfig['i18n']>['routing'];

package/dist/core/app/common.js

@@ -1,37 +1,64 @@
-import { decodeKey } from "../encryption.js";
-import { NOOP_MIDDLEWARE_FN } from "../middleware/noop-middleware.js";
-import { deserializeRouteData } from "../routing/manifest/serialization.js";
-function deserializeManifest(serializedManifest) {
-  const routes = [];
-  for (const serializedRoute of serializedManifest.routes) {
-    routes.push({
-      ...serializedRoute,
-      routeData: deserializeRouteData(serializedRoute.routeData)
-    });
-    const route = serializedRoute;
-    route.routeData = deserializeRouteData(serializedRoute.routeData);
+function toRoutingStrategy(routing, domains) {
+  let strategy;
+  const hasDomains = domains ? Object.keys(domains).length > 0 : false;
+  if (routing === "manual") {
+    strategy = "manual";
+  } else {
+    if (!hasDomains) {
+      if (routing?.prefixDefaultLocale === true) {
+        if (routing.redirectToDefaultLocale) {
+          strategy = "pathname-prefix-always";
+        } else {
+          strategy = "pathname-prefix-always-no-redirect";
+        }
+      } else {
+        strategy = "pathname-prefix-other-locales";
+      }
+    } else {
+      if (routing?.prefixDefaultLocale === true) {
+        if (routing.redirectToDefaultLocale) {
+          strategy = "domains-prefix-always";
+        } else {
+          strategy = "domains-prefix-always-no-redirect";
+        }
+      } else {
+        strategy = "domains-prefix-other-locales";
+      }
+    }
   }
-  const assets = new Set(serializedManifest.assets);
-  const componentMetadata = new Map(serializedManifest.componentMetadata);
-  const inlinedScripts = new Map(serializedManifest.inlinedScripts);
-  const clientDirectives = new Map(serializedManifest.clientDirectives);
-  const serverIslandNameMap = new Map(serializedManifest.serverIslandNameMap);
-  const key = decodeKey(serializedManifest.key);
-  return {
-    // in case user middleware exists, this no-op middleware will be reassigned (see plugin-ssr.ts)
-    middleware() {
-      return { onRequest: NOOP_MIDDLEWARE_FN };
-    },
-    ...serializedManifest,
-    assets,
-    componentMetadata,
-    inlinedScripts,
-    clientDirectives,
-    routes,
-    serverIslandNameMap,
-    key
-  };
+  return strategy;
+}
+function toFallbackType(routing) {
+  if (routing === "manual") {
+    return "rewrite";
+  }
+  return routing.fallbackType;
+}
+const PREFIX_DEFAULT_LOCALE = /* @__PURE__ */ new Set([
+  "pathname-prefix-always",
+  "domains-prefix-always",
+  "pathname-prefix-always-no-redirect",
+  "domains-prefix-always-no-redirect"
+]);
+const REDIRECT_TO_DEFAULT_LOCALE = /* @__PURE__ */ new Set([
+  "pathname-prefix-always-no-redirect",
+  "domains-prefix-always-no-redirect"
+]);
+function fromRoutingStrategy(strategy, fallbackType) {
+  let routing;
+  if (strategy === "manual") {
+    routing = "manual";
+  } else {
+    routing = {
+      prefixDefaultLocale: PREFIX_DEFAULT_LOCALE.has(strategy),
+      redirectToDefaultLocale: !REDIRECT_TO_DEFAULT_LOCALE.has(strategy),
+      fallbackType
+    };
+  }
+  return routing;
 }
 export {
-  deserializeManifest
+  fromRoutingStrategy,
+  toFallbackType,
+  toRoutingStrategy
 };

package/dist/core/app/dev/app.d.ts

@@ -0,0 +1,15 @@
+import type { RouteData } from '../../../types/public/index.js';
+import type { Logger } from '../../logger/core.js';
+import type { CreateRenderContext, RenderContext } from '../../render-context.js';
+import { BaseApp, type RenderErrorOptions } from '../base.js';
+import type { SSRManifest } from '../types.js';
+import { DevPipeline } from './pipeline.js';
+export declare class DevApp extends BaseApp<DevPipeline> {
+    logger: Logger;
+    currentRenderContext: RenderContext | undefined;
+    constructor(manifest: SSRManifest, streaming: boolean | undefined, logger: Logger);
+    createPipeline(streaming: boolean, manifest: SSRManifest, logger: Logger): DevPipeline;
+    match(request: Request): RouteData | undefined;
+    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
+    renderError(request: Request, { locals, skipMiddleware, error, clientAddress, status }: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/app/dev/app.js

@@ -0,0 +1,86 @@
+import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "../../errors/errors-data.js";
+import { isAstroError } from "../../errors/index.js";
+import { isRoute404, isRoute500 } from "../../routing/match.js";
+import { BaseApp } from "../base.js";
+import { DevPipeline } from "./pipeline.js";
+class DevApp extends BaseApp {
+  logger;
+  currentRenderContext = void 0;
+  constructor(manifest, streaming = true, logger) {
+    super(manifest, streaming, logger);
+    this.logger = logger;
+  }
+  createPipeline(streaming, manifest, logger) {
+    return DevPipeline.create({
+      logger,
+      manifest,
+      streaming
+    });
+  }
+  match(request) {
+    return super.match(request, true);
+  }
+  async createRenderContext(payload) {
+    this.currentRenderContext = await super.createRenderContext(payload);
+    return this.currentRenderContext;
+  }
+  async renderError(request, { locals, skipMiddleware = false, error, clientAddress, status }) {
+    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+      throw error;
+    }
+    const renderRoute = async (routeData) => {
+      try {
+        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
+        const renderContext = await this.createRenderContext({
+          locals,
+          pipeline: this.pipeline,
+          pathname: this.getPathnameFromRequest(request),
+          skipMiddleware,
+          request,
+          routeData,
+          clientAddress,
+          status,
+          shouldInjectCspMetaTags: false
+        });
+        renderContext.props.error = error;
+        const response = await renderContext.render(preloadedComponent);
+        if (error) {
+          this.logger.error("router", error.stack || error.message);
+        }
+        return response;
+      } catch (_err) {
+        if (skipMiddleware === false) {
+          return this.renderError(request, {
+            clientAddress: void 0,
+            prerenderedErrorPageFetch: fetch,
+            status: 500,
+            skipMiddleware: true,
+            error: _err
+          });
+        }
+        throw _err;
+      }
+    };
+    if (status === 404) {
+      const custom400 = getCustom400Route(this.manifestData);
+      if (custom400) {
+        return renderRoute(custom400);
+      }
+    }
+    const custom500 = getCustom500Route(this.manifestData);
+    if (!custom500) {
+      throw error;
+    } else {
+      return renderRoute(custom500);
+    }
+  }
+}
+function getCustom500Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute500(r.route));
+}
+function getCustom400Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute404(r.route));
+}
+export {
+  DevApp
+};

package/dist/core/app/dev/pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentInstance } from '../../../types/astro.js';
+import type { RewritePayload, RouteData } from '../../../types/public/index.js';
+import { type HeadElements, Pipeline, type TryRewriteResult } from '../../base-pipeline.js';
+type DevPipelineCreate = Pick<DevPipeline, 'logger' | 'manifest' | 'streaming'>;
+export declare class DevPipeline extends Pipeline {
+    getName(): string;
+    static create({ logger, manifest, streaming }: DevPipelineCreate): DevPipeline;
+    headElements(routeData: RouteData): Promise<HeadElements>;
+    componentMetadata(): void;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
+}
+export {};