astro 7.0.0-alpha.1 → 7.0.0-alpha.2

package/dist/assets/utils/metadata.js

@@ -10,7 +10,7 @@ async function imageMetadata(data, src) {
       message: AstroErrorData.NoImageMetadata.message(src)
     });
   }
-  if (!result.height || !result.width || !result.type) {
+  if (result.height == null || result.width == null || !result.type) {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)

package/dist/assets/utils/vendor/image-size/types/svg.js

@@ -77,7 +77,7 @@ const SVG = {
     const root = extractorRegExps.root.exec(toUTF8String(input));
     if (root) {
       const attrs = parseAttributes(root[0]);
-      if (attrs.width && attrs.height) {
+      if (attrs.width != null && attrs.height != null) {
         return calculateByDimensions(attrs);
       }
       if (attrs.viewbox) {

package/dist/cli/dev/background.d.ts

@@ -0,0 +1,16 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface BackgroundResult {
+    pid: number;
+    url: string;
+    existing?: boolean;
+}
+export interface BackgroundErrorResult {
+    error: string;
+    message: string;
+}
+export declare function formatBackgroundOutput(result: BackgroundResult | BackgroundErrorResult): string;
+export declare function background({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/background.js

@@ -0,0 +1,116 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  checkExistingServer,
+  getLogFileURL,
+  readLockFile,
+  removeLockFile,
+  isProcessAlive,
+  GRACEFUL_SHUTDOWN_TIMEOUT
+} from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatBackgroundOutput(result) {
+  return JSON.stringify(result);
+}
+async function background({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (existing && !flags.force) {
+    logger.info(
+      "SKIP_FORMAT",
+      `Dev server already running at ${existing.url} (pid ${existing.pid})
+  Stop:   astro dev stop
+  Status: astro dev status
+  Logs:   astro dev logs`
+    );
+    return;
+  }
+  if (existing && flags.force) {
+    try {
+      process.kill(existing.pid, "SIGTERM");
+    } catch {
+    }
+    const deadline2 = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+    while (Date.now() < deadline2) {
+      if (!isProcessAlive(existing.pid)) break;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    if (isProcessAlive(existing.pid)) {
+      try {
+        process.kill(existing.pid, "SIGKILL");
+      } catch {
+      }
+    }
+    removeLockFile(root);
+  }
+  const args = ["dev"];
+  if (flags.port) args.push("--port", String(flags.port));
+  if (flags.host != null) {
+    if (typeof flags.host === "string") {
+      args.push("--host", flags.host);
+    } else {
+      args.push("--host");
+    }
+  }
+  if (flags.config) args.push("--config", String(flags.config));
+  if (flags.root) args.push("--root", String(flags.root));
+  if (flags.allowedHosts) args.push("--allowed-hosts", String(flags.allowedHosts));
+  if (flags.experimentalJson) args.push("--experimental-json");
+  const logFileURL = getLogFileURL(root);
+  const logFilePath = fileURLToPath(logFileURL);
+  const dotAstroDir = fileURLToPath(new URL(".astro/", root));
+  if (!existsSync(dotAstroDir)) {
+    mkdirSync(dotAstroDir, { recursive: true });
+  }
+  const logFd = openSync(logFilePath, "w");
+  const rootPath = fileURLToPath(root);
+  const astroBin = resolve(rootPath, "node_modules", ".bin", "astro");
+  const child = spawn(astroBin, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: rootPath,
+    env: { ...process.env, ASTRO_DEV_BACKGROUND: "1" }
+  });
+  child.unref();
+  const childPid = child.pid;
+  if (!childPid) {
+    logger.error("SKIP_FORMAT", "Failed to spawn background dev server process.");
+    process.exit(1);
+  }
+  const timeout = 3e4;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(childPid)) {
+      logger.error("SKIP_FORMAT", "Dev server process exited before becoming ready.");
+      process.exit(1);
+    }
+    const lockData = readLockFile(root);
+    if (lockData && lockData.pid === childPid) {
+      logger.info(
+        "SKIP_FORMAT",
+        `Dev server running at ${lockData.url} (pid ${lockData.pid})
+  Stop:   astro dev stop
+  Status: astro dev status
+  Logs:   astro dev logs`
+      );
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    process.kill(childPid, "SIGTERM");
+  } catch {
+  }
+  removeLockFile(root);
+  logger.error("SKIP_FORMAT", `Dev server failed to start within ${timeout / 1e3}s.`);
+  process.exit(1);
+}
+export {
+  background,
+  formatBackgroundOutput
+};

package/dist/cli/dev/index.js

@@ -1,14 +1,31 @@
+import { isAgent } from "am-i-vibing";
 import colors from "piccolore";
 import devServer from "../../core/dev/index.js";
+import { pathToFileURL } from "node:url";
+import { checkExistingServer, removeLockFile, writeLockFile } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
-import { flagsToAstroInlineConfig } from "../flags.js";
+import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
+function isRunByAgent() {
+  try {
+    return isAgent();
+  } catch {
+    return false;
+  }
+}
 async function dev({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro dev",
-      usage: "[...flags]",
+      usage: "[command] [...flags]",
       tables: {
+        Commands: [
+          ["stop", "Stop a running background dev server."],
+          ["status", "Check if a dev server is running."],
+          ["logs [--follow]", "View logs from a background dev server."]
+        ],
         Flags: [
+          ["--background", "Start the dev server as a background process."],
           ["--mode", `Specify the mode of the project. Defaults to "development".`],
           ["--port", `Specify which port to run on. Defaults to 4321.`],
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
@@ -28,8 +45,70 @@ async function dev({ flags }) {
     });
     return;
   }
+  const agentDetected = !process.env.ASTRO_DEV_BACKGROUND && isRunByAgent();
+  if (agentDetected) {
+    flags.experimentalJson = true;
+  }
+  const logger = createLoggerFromFlags(flags);
+  const subcommand = flags._[3]?.toString();
+  if (subcommand === "stop") {
+    const { stop } = await import("./stop.js");
+    await stop({ flags, logger });
+    return;
+  }
+  if (subcommand === "status") {
+    const { status } = await import("./status.js");
+    await status({ flags, logger });
+    return;
+  }
+  if (subcommand === "logs") {
+    const { logs } = await import("./logs.js");
+    await logs({ flags, logger });
+    return;
+  }
+  if (flags.background || agentDetected) {
+    const { background } = await import("./background.js");
+    await background({ flags, logger });
+    return;
+  }
+  if (subcommand) {
+    logger.error(
+      "SKIP_FORMAT",
+      `Unknown command: astro dev ${subcommand}
+
+Run \`astro dev --help\` to see available commands.`
+    );
+    process.exit(1);
+  }
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existingServer = checkExistingServer(root);
+  if (existingServer) {
+    const message = [
+      "Another astro dev server is already running.",
+      "",
+      `  URL:  ${existingServer.url}`,
+      `  PID:  ${existingServer.pid}`,
+      "",
+      `Run \`astro dev stop\` to stop it, or use \`astro dev --force\` to replace it.`
+    ].join("\n");
+    throw new Error(message);
+  }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  return await devServer(inlineConfig);
+  const server = await devServer(inlineConfig);
+  const serverUrl = new URL(server.resolvedUrls.local[0]).origin;
+  writeLockFile(root, {
+    pid: process.pid,
+    port: server.address.port,
+    url: serverUrl,
+    background: !!process.env.ASTRO_DEV_BACKGROUND,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const originalStop = server.stop.bind(server);
+  server.stop = async () => {
+    removeLockFile(root);
+    await originalStop();
+  };
+  return server;
 }
 export {
   dev

package/dist/cli/dev/logs.d.ts

@@ -0,0 +1,6 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export declare function logs({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/logs.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync, statSync, createReadStream, watch } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { checkExistingServer, getLogFileURL, isProcessAlive } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+async function logs({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.error("SKIP_FORMAT", "No dev server is running.");
+    process.exit(1);
+  }
+  if (!existing.background) {
+    logger.error(
+      "SKIP_FORMAT",
+      "The running dev server was not started with `astro dev --background`. View logs in the terminal where it was started."
+    );
+    process.exit(1);
+  }
+  const logFileURL = getLogFileURL(root);
+  const logFilePath = fileURLToPath(logFileURL);
+  if (!existsSync(logFilePath)) {
+    logger.error("SKIP_FORMAT", "No log file found.");
+    process.exit(1);
+  }
+  const follow = flags.follow || flags.f;
+  if (!follow) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+    return;
+  }
+  let offset = statSync(logFilePath).size;
+  if (offset > 0) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+  }
+  const watcher = watch(logFilePath, () => {
+    const currentSize = statSync(logFilePath).size;
+    if (currentSize > offset) {
+      const stream = createReadStream(logFilePath, { start: offset, encoding: "utf-8" });
+      stream.on("data", (chunk) => process.stdout.write(chunk));
+      stream.on("end", () => {
+        offset = currentSize;
+      });
+    }
+  });
+  const aliveCheck = setInterval(() => {
+    if (!isProcessAlive(existing.pid)) {
+      const currentSize = statSync(logFilePath).size;
+      if (currentSize > offset) {
+        const remaining = readFileSync(logFilePath, { encoding: "utf-8" }).slice(offset);
+        process.stdout.write(remaining);
+      }
+      watcher.close();
+      clearInterval(aliveCheck);
+    }
+  }, 1e3);
+  const cleanup = () => {
+    watcher.close();
+    clearInterval(aliveCheck);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+export {
+  logs
+};

package/dist/cli/dev/status.d.ts

@@ -0,0 +1,15 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StatusResult {
+    running: boolean;
+    pid?: number;
+    url?: string;
+    port?: number;
+    background?: boolean;
+    uptime?: number;
+}
+export declare function formatStatusOutput(result: StatusResult): string;
+export declare function status({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/status.js

@@ -0,0 +1,27 @@
+import { pathToFileURL } from "node:url";
+import { checkExistingServer } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStatusOutput(result) {
+  return JSON.stringify(result);
+}
+async function status({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  const startedAt = new Date(existing.startedAt).getTime();
+  const uptime = Math.floor((Date.now() - startedAt) / 1e3);
+  logger.info(
+    "SKIP_FORMAT",
+    `Dev server running at ${existing.url} (pid ${existing.pid}, uptime ${uptime}s${existing.background ? ", background" : ""})`
+  );
+}
+export {
+  formatStatusOutput,
+  status
+};

package/dist/cli/dev/stop.d.ts

@@ -0,0 +1,12 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StopResult {
+    stopped: boolean;
+    pid?: number;
+    reason?: string;
+}
+export declare function formatStopOutput(result: StopResult): string;
+export declare function stop({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/stop.js

@@ -0,0 +1,43 @@
+import { pathToFileURL } from "node:url";
+import {
+  checkExistingServer,
+  removeLockFile,
+  isProcessAlive,
+  GRACEFUL_SHUTDOWN_TIMEOUT
+} from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStopOutput(result) {
+  return JSON.stringify(result);
+}
+async function stop({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  try {
+    process.kill(existing.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(existing.pid)) break;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (isProcessAlive(existing.pid)) {
+    try {
+      process.kill(existing.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removeLockFile(root);
+  logger.info("SKIP_FORMAT", `Stopped dev server (pid ${existing.pid}).`);
+}
+export {
+  formatStopOutput,
+  stop
+};

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.0.0-alpha.1";
+  version = "7.0.0-alpha.2";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -1,8 +1,5 @@
 import { existsSync, promises as fs } from "node:fs";
-import {
-  createMarkdownProcessor,
-  parseFrontmatter
-} from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import PQueue from "p-queue";
 import xxhash from "xxhash-wasm";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
@@ -28,7 +25,7 @@ class ContentLayer {
   #watcher;
   #lastConfigDigest;
   #unsubscribe;
-  #markdownProcessor;
+  #markdownRenderer;
   #generateDigest;
   #contentConfigObserver;
   #queue;
@@ -108,9 +105,18 @@ class ContentLayer {
     };
   }
   async #processMarkdown(content, options) {
-    this.#markdownProcessor ??= await createMarkdownProcessor(this.#settings.config.markdown);
+    if (!this.#markdownRenderer) {
+      const { markdown, image } = this.#settings.config;
+      this.#markdownRenderer = await markdown.processor.createRenderer({
+        image,
+        syntaxHighlight: markdown.syntaxHighlight,
+        shikiConfig: markdown.shikiConfig,
+        gfm: markdown.gfm,
+        smartypants: markdown.smartypants
+      });
+    }
     const { frontmatter, content: body } = parseFrontmatter(content);
-    const { code, metadata } = await this.#markdownProcessor.render(body, {
+    const { code, metadata } = await this.#markdownRenderer.render(body, {
       frontmatter,
       fileURL: options?.fileURL
     });
@@ -191,7 +197,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.0.0-alpha.1") {
+    if (previousAstroVersion && previousAstroVersion !== "7.0.0-alpha.2") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -199,8 +205,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.0.0-alpha.1") {
-      this.#store.metaStore().set("astro-version", "7.0.0-alpha.1");
+    if ("7.0.0-alpha.2") {
+      this.#store.metaStore().set("astro-version", "7.0.0-alpha.2");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/data-store.d.ts

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 export interface RenderedContent {
     /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
     html: string;

package/dist/content/runtime-assets.d.ts

@@ -2,10 +2,10 @@ import type { Rolldown } from 'vite';
 import * as z from 'zod/v4';
 export declare function createImage(pluginContext: Rolldown.PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
     ASTRO_ASSET: string;
-    format: import("../assets/types.js").ImageInputFormat;
-    src: string;
     width: number;
     height: number;
+    format: import("../assets/types.js").ImageInputFormat;
+    src: string;
     fsPath: string;
     orientation?: number | undefined;
 }, string>>;

package/dist/content/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 import * as z from 'zod/v4';
 import type * as zCore from 'zod/v4/core';
 import type { ImageMetadata } from '../assets/types.js';

package/dist/content/runtime.js

@@ -134,9 +134,10 @@ function createGetEntry({ liveCollections }) {
         return;
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
-      entry.data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
+      const data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
       const result = {
         ...entry,
+        data,
         collection
       };
       warnForPropertyAccess(
@@ -321,7 +322,9 @@ async function updateImageReferencesInBody(html, fileName) {
   const { getImage } = await import("virtual:astro:get-image");
   for (const [_full, imagePath] of html.matchAll(CONTENT_LAYER_IMAGE_REGEX)) {
     try {
-      const decodedImagePath = JSON.parse(imagePath.replaceAll(""", '"'));
+      const decodedImagePath = JSON.parse(
+        imagePath.replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'")
+      );
       let image;
       if (URL.canParse(decodedImagePath.src)) {
         image = await getImage(decodedImagePath);
@@ -350,11 +353,12 @@ async function updateImageReferencesInBody(html, fileName) {
       srcset: image.srcSet.attribute,
       // This attribute is used by the toolbar audit
       ...import.meta.env.DEV ? { "data-image-component": "true" } : {}
-    }).map(([key, value]) => value ? `${key}="${escape(value)}"` : "").join(" ");
+    }).filter(([, value]) => value != null).map(([key, value]) => value === "" ? `${key}=""` : `${key}="${escape(String(value))}"`).join(" ");
   });
 }
 function updateImageReferencesInData(data, fileName, imageAssetMap) {
-  return new Traverse(data).map(function(ctx, val) {
+  const copy = structuredClone(data);
+  new Traverse(copy).forEach(function(ctx, val) {
     if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
       const src = val.replace(IMAGE_IMPORT_PREFIX, "");
       const id = imageSrcToImportId(src, fileName);
@@ -375,6 +379,7 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
       }
     }
   });
+  return copy;
 }
 async function renderEntry(entry) {
   if (!entry) {

package/dist/content/types-generator.js

@@ -447,7 +447,11 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
     zodSchemaForJson = await getContentLayerSchema(collectionConfig, collectionKey);
   }
   if (collectionConfig.type === CONTENT_LAYER_TYPE && collectionConfig.loader.name === "file-loader") {
-    zodSchemaForJson = z.object({}).catchall(zodSchemaForJson);
+    const itemSchema = zodSchemaForJson;
+    zodSchemaForJson = z.union([
+      z.array(itemSchema),
+      z.object({ $schema: z.string().optional() }).catchall(itemSchema)
+    ]);
   }
   if (zodSchemaForJson instanceof z.ZodObject) {
     const existingMeta = z.globalRegistry.get(zodSchemaForJson);

package/dist/content/utils.d.ts

@@ -124,7 +124,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     slug: string;
 };
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir' | 'root'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
-export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/markdown-remark").ParseFrontmatterResult;
+export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/internal-helpers/frontmatter").ParseFrontmatterResult;
 /**
  * The content config is loaded separately from other `src/` files.
  * This global observable lets dependent plugins (like the content flag plugin)

package/dist/content/utils.js

@@ -1,7 +1,7 @@
 import fsMod from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { parseFrontmatter } from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import { slug as githubSlug } from "github-slugger";
 import colors from "piccolore";
 import xxhash from "xxhash-wasm";

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

@@ -131,6 +131,15 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     abstract createPipeline(streaming: boolean, manifest: SSRManifest, ...args: any[]): P;
     set setManifestData(newManifestData: RoutesList);
     removeBase(pathname: string): string;
+    /**
+     * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
+     * contains an invalid percent-sequence (e.g. `%C0%AF`, an overlong-UTF-8 encoding of
+     * `/` commonly sent by path-traversal scanners). A raw `decodeURI()` would throw
+     * `URIError: URI malformed`, and because `match()` runs before `render()` that error
+     * escapes the adapter's request handler as an uncaught exception (HTTP 500) that user
+     * middleware can't catch.
+     */
+    private safeDecodeURI;
     /**
      * Extracts the base-stripped, decoded pathname from a request.
      * Used by adapters to compute the pathname for dev-mode route matching.