snappy-prerender 2.6.0-rc.3 → 2.7.0

package/src/core/prune.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MANIFEST_FILE = '.snappy-manifest.json';
+
+/**
+ * Reads the file list the previous run wrote. A missing or malformed manifest simply
+ * disables pruning, so an older output directory can be upgraded safely.
+ */
+export async function readPruneManifest(dir) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(path.join(dir, MANIFEST_FILE), 'utf8'));
+    return Array.isArray(parsed.files) ? parsed.files : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Deletes files the previous run generated that this run no longer produces, then
+ * removes emptied route directories. Only paths recorded in the manifest are touched,
+ * so assets and files the user added are never at risk.
+ */
+export async function pruneStaleFiles({ dir, previous, current, log }) {
+  if (!Array.isArray(previous)) return [];
+  const keep = new Set(current);
+  const root = path.resolve(dir);
+  const removed = [];
+  for (const file of previous) {
+    if (typeof file !== 'string' || keep.has(file)) continue;
+    if (file === MANIFEST_FILE || file === 'robots.txt') continue;
+    const target = path.resolve(root, file);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) continue;
+    try {
+      await fs.rm(target, { force: true });
+      removed.push(file);
+      await removeEmptyParents(root, path.dirname(target));
+    } catch (error) {
+      log?.warn(`could not prune ${file}: ${error.message}`);
+    }
+  }
+  return removed;
+}
+
+// Writes the manifest for the next run. Files that are not ours to own are excluded.
+export async function writePruneManifest({ dir, files }) {
+  const owned = [...new Set(files)].filter(
+    (file) => file !== MANIFEST_FILE && file !== 'robots.txt',
+  );
+  const contents = `${JSON.stringify({ version: 1, files: owned.sort() }, null, 2)}\n`;
+  await fs.writeFile(path.join(dir, MANIFEST_FILE), contents, 'utf8');
+}
+
+// Removes parent directories that became empty, stopping at the output root.
+async function removeEmptyParents(root, start) {
+  let current = start;
+  while (current !== root && current.startsWith(`${root}${path.sep}`)) {
+    try {
+      await fs.rmdir(current);
+    } catch {
+      return;
+    }
+    current = path.dirname(current);
+  }
+}

package/src/core/render.js

@@ -1,9 +1,8 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { captureFormState } from './form-state.js';
 import { inlineStylesheets } from './inline-css.js';
+import { isPageEmpty } from './page-content.js';
 import { createResourceCollector } from './resources.js';
-import { toAppRoute, toServerUrl } from './routes.js';
+import { normaliseRoute, toAppRoute, toServerUrl } from './routes.js';
 import { captureRuntimeStyles } from './runtime-styles.js';
 import { freezeAnimations, scrollThroughPage, settlePage, trackNetwork } from './settle.js';
 import { separateTextNodes } from './text-separators.js';
@@ -27,20 +26,55 @@ function escapeForScript(value) {
  * storage from leaking between routes. When a screenshot path is supplied the route
  * is captured as an image instead of HTML.
  */
-export async function renderRoute({ browser, origin, route, config, screenshotPath }) {
+export async function renderRoute({
+  browser,
+  origin,
+  route,
+  config,
+  screenshot = false,
+  traceFile = null,
+}) {
   const context = await browser.newContext({
     viewport: config.viewport,
     storageState: config.storageState ?? undefined,
     userAgent: config.userAgent ?? undefined,
     ignoreHTTPSErrors: config.ignoreHTTPSErrors,
     reducedMotion: config.freezeAnimations ? 'reduce' : 'no-preference',
+    serviceWorkers: 'block',
   });
+  let tracing = false;
+  if (traceFile) {
+    await context.tracing.start({ screenshots: false, snapshots: true, sources: false });
+    tracing = true;
+  }
   const page = await context.newPage();
   const pageErrors = [];
+  const consoleErrors = [];
+  const failedRequests = [];
   let inlineCssSkipped = [];
   page.on('pageerror', (error) => pageErrors.push(error.message));
+  page.on('console', (message) => {
+    if (message.type() === 'error') consoleErrors.push(message.text());
+  });
+  // Only same-origin failures are the build's own to fix; a blocked analytics host is
+  // not a broken page. Aborted requests are navigations or cancelled fetches, not 404s.
+  page.on('response', (response) => {
+    if (response.status() < 400) return;
+    const parsed = parseHttpUrl(response.url());
+    if (parsed?.origin !== origin) return;
+    failedRequests.push({ url: response.url(), status: response.status() });
+  });
+  page.on('requestfailed', (request) => {
+    const parsed = parseHttpUrl(request.url());
+    if (parsed?.origin !== origin) return;
+    const error = request.failure()?.errorText ?? 'request failed';
+    if (error.includes('ERR_ABORTED')) return;
+    failedRequests.push({ url: request.url(), status: null, error });
+  });
 
-  const metadataDefaults = config.metadata ? { base: config.base, ...config.metadata } : null;
+  const metadataDefaults = config.metadata
+    ? { base: config.base, flatOutput: config.flatOutput, ...config.metadata }
+    : null;
   if (metadataDefaults) {
     await page.addInitScript((defaults) => {
       window.__SNAPPY_META__ = defaults;
@@ -56,13 +90,51 @@ export async function renderRoute({ browser, origin, route, config, screenshotPa
     maxCachedBytes: config.maxCachedBytes,
   });
   await collector.install(page);
+  await page.addInitScript(() => {
+    window.__snappyLcp = [];
+    try {
+      const observer = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const element = entry.element;
+          window.__snappyLcp.push({
+            url: entry.url || element?.currentSrc || element?.src || null,
+          });
+        }
+      });
+      observer.observe({ type: 'largest-contentful-paint', buffered: true });
+    } catch {
+      // Older engines simply do not report LCP; preload injection falls back to no hint.
+    }
+  });
   const tracker = trackNetwork(page);
   try {
-    await page.goto(toServerUrl(route, config.base, origin), {
+    const response = await page.goto(toServerUrl(route, config.base, origin), {
       waitUntil: 'domcontentloaded',
       timeout: config.timeout,
     });
+    const notFoundRoute = config.notFoundRoute ? normaliseRoute(config.notFoundRoute) : null;
+    const isNotFoundRoute = notFoundRoute !== null && normaliseRoute(route) === notFoundRoute;
+    if (response && response.status() >= 400) {
+      // A configured 404 route may legitimately answer with HTTP 404; every other status
+      // is a failure, and the marker cannot be read before the navigation completes.
+      if (!(response.status() === 404 && isNotFoundRoute)) {
+        const error = new Error(
+          `route responded with HTTP ${response.status()}${response.statusText() ? ` ${response.statusText()}` : ''}`,
+        );
+        // A server error can be transient and is retried; a client error is the app's own.
+        error.retryable = response.status() >= 500;
+        throw error;
+      }
+    }
     await settlePage(page, config, tracker);
+    const empty = await isPageEmpty(page);
+    const statusCode = await page.evaluate(() => {
+      const marker = document.querySelector('meta[name="prerender-status-code"]');
+      if (!marker) return null;
+      const value = Number.parseInt(marker.getAttribute('content') ?? '', 10);
+      return Number.isFinite(value) ? value : null;
+    });
+    const finalUrl = page.url();
 
     if (config.captureRuntimeStyles) await captureRuntimeStyles(page);
     if (config.captureFormState) await captureFormState(page);
@@ -78,32 +150,86 @@ export async function renderRoute({ browser, origin, route, config, screenshotPa
     if (metadataDefaults) await injectMetadataDefaults(page, metadataDefaults);
     if (config.freezeAnimations) await freezeAnimations(page);
     if (config.scrollToBottom) await scrollThroughPage(page, config);
+    const lcpUrl = await page.evaluate(() => window.__snappyLcp?.at(-1)?.url ?? null);
+    let lcpImage = null;
+    if (lcpUrl) {
+      try {
+        const parsed = new URL(lcpUrl);
+        if (parsed.origin === origin) lcpImage = `${parsed.pathname}${parsed.search}`;
+      } catch {
+        // Ignore malformed performance entries.
+      }
+    }
     await separateTextNodes(page);
 
     const links = await collectLinks(page, config.base, origin);
 
-    if (screenshotPath) {
-      await fs.mkdir(path.dirname(screenshotPath), { recursive: true });
-      await page.screenshot({ path: screenshotPath, fullPage: true });
+    if (screenshot) {
+      const buffer = await page.screenshot({
+        fullPage: true,
+        type: config.saveAs === 'jpeg' ? 'jpeg' : 'png',
+      });
       return {
         route,
         links,
         pageErrors,
+        consoleErrors,
+        failedRequests,
         collector,
         inlineCssSkipped,
         stateScript,
-        screenshot: true,
+        screenshot: buffer,
+        empty,
+        statusCode,
+        httpStatus: response?.status() ?? null,
+        finalUrl,
+        lcpImage,
       };
     }
 
     const html = await page.content();
-    return { route, html, links, pageErrors, collector, inlineCssSkipped, stateScript };
+    return {
+      route,
+      html,
+      links,
+      pageErrors,
+      consoleErrors,
+      failedRequests,
+      collector,
+      inlineCssSkipped,
+      stateScript,
+      empty,
+      statusCode,
+      httpStatus: response?.status() ?? null,
+      finalUrl,
+      lcpImage,
+    };
+  } catch (error) {
+    error.retryable ??= isRetryableRenderError(error);
+    if (tracing) {
+      tracing = false;
+      await context.tracing.stop({ path: traceFile }).then(
+        () => {
+          error.tracePath = traceFile;
+        },
+        // A failed trace must never replace the render error that explains the build failure.
+        () => {},
+      );
+    }
+    throw error;
   } finally {
     tracker.stop();
+    if (tracing) await context.tracing.stop().catch(() => {});
     await context.close();
   }
 }
 
+// Navigation and network failures are transient; a bad selector or an HTTP status is not.
+function isRetryableRenderError(error) {
+  if (error?.name === 'TimeoutError') return true;
+  return /net::ERR_|timed? ?out|ECONNRESET|ECONNREFUSED|socket hang up/i.test(error?.message ?? '');
+}
+
 /**
  * Injects captured JSON responses as window.snapStore and anything the app exposes
  * through window.snapSaveState, before the first script runs. The client can then
@@ -226,3 +352,13 @@ async function collectLinks(page, base, origin) {
   }
   return routes;
 }
+
+// Parses an HTTP URL, returning null for data, blob and other non-network URLs.
+function parseHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:' ? parsed : null;
+  } catch {
+    return null;
+  }
+}

package/src/core/report.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { writeFileIfChanged } from './output.js';
+
+/**
+ * Writes the machine-readable run report. The JSON is deliberately limited to route,
+ * audit and artifact data; configuration and captured state are never serialised.
+ */
+export async function writeReport({ report, config, log }) {
+  if (!config.reportPath) return null;
+  const contents = `${JSON.stringify(buildReport(report, config), null, 2)}\n`;
+  if (config.dryRun) {
+    log.info(`Dry run: would write report to ${config.reportPath}`);
+    return { file: config.reportPath, status: 'dry-run' };
+  }
+  const target = path.resolve(config.reportPath);
+  const written = await writeFileIfChanged({
+    dir: path.dirname(target),
+    file: path.basename(target),
+    contents,
+  });
+  log.info(`Wrote report to ${config.reportPath}`);
+  return { file: config.reportPath, status: written.status };
+}
+
+/**
+ * Shapes the public report document. `routes` here is an array of per-route records;
+ * the programmatic `report.routes` stays a list of route strings. URLs are reduced to
+ * origin and path, and the configured storage-state path is redacted everywhere, so a
+ * report can be attached to a build log without leaking credentials or session data.
+ */
+export function buildReport(report, config = null) {
+  const audit = report.audit ?? { errors: [], warnings: [], linksChecked: 0 };
+  const document = {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    durationMs: report.durationMs,
+    ok: report.ok,
+    summary: {
+      routes: report.routeDetails.length,
+      files: report.files.filter((file) => file.status !== 'dry-run').length,
+      errors: uniqueErrorCount(report, audit),
+      warnings: audit.warnings.length,
+    },
+    routes: report.routeDetails,
+    verification: report.verification
+      ? {
+          ok: report.verification.ok,
+          modes: report.verification.modes,
+          frameworks: report.verification.frameworks,
+          skipped: report.verification.skipped ?? 0,
+          errors: report.verification.errors,
+        }
+      : null,
+    audit,
+    sitemap: report.sitemap,
+    preloadManifest: report.preloadManifest,
+    truncated: report.truncated,
+    notFoundRoutes: report.notFoundRoutes,
+    duplicateOutputs: report.duplicatePages,
+    routeSources: report.routeSources ?? [],
+    cspSkipped: report.cspSkipped ?? [],
+    traces: report.traces ?? [],
+  };
+  return sanitiseValue(document, config);
+}
+
+// Counts route errors once even when the audit mirrors them as findings.
+function uniqueErrorCount(report, audit) {
+  const seen = new Set();
+  for (const error of [...(report.errors ?? []), ...(audit.errors ?? [])]) {
+    seen.add(`${error.route ?? ''}|${error.message ?? ''}`);
+  }
+  return seen.size;
+}
+
+// Recursively redacts URLs and the configured storage-state path from report strings.
+function sanitiseValue(value, config) {
+  if (Array.isArray(value)) return value.map((entry) => sanitiseValue(entry, config));
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, sanitiseValue(entry, config)]),
+    );
+  }
+  if (typeof value !== 'string') return value;
+  let text = value;
+  if (config?.storageState) {
+    for (const secret of [config.storageState, path.resolve(config.storageState)]) {
+      text = text.split(secret).join('[redacted]');
+    }
+  }
+  return text.replace(/https?:\/\/[^\s"'<>]+/gi, redactUrl);
+}
+
+// Removes credentials, query strings and fragments from an absolute URL.
+function redactUrl(raw) {
+  const trailing = /[.,;)\]]+$/.exec(raw)?.[0] ?? '';
+  const urlText = trailing ? raw.slice(0, -trailing.length) : raw;
+  try {
+    const url = new URL(urlText);
+    url.username = '';
+    url.password = '';
+    url.search = '';
+    url.hash = '';
+    return `${url.href}${trailing}`;
+  } catch {
+    return raw;
+  }
+}

package/src/core/resources.js

@@ -18,6 +18,7 @@ export function createResourceCollector({
   const images = new Set();
   const scripts = new Set();
   const styles = new Set();
+  const fonts = new Map();
   const json = new Map();
   const pending = [];
 
@@ -26,6 +27,7 @@ export function createResourceCollector({
     images,
     scripts,
     styles,
+    fonts,
     json,
     // Waits for in-flight JSON body reads so the cache is complete before injection.
     async settled() {
@@ -49,6 +51,7 @@ export function createResourceCollector({
         const url = request.url();
         const parsed = parseUrl(url);
         if (!parsed || parsed.origin !== origin) return;
+        if (response.status() >= 400) return;
         const path = toAppPath(url, base);
         if (!path) return;
 
@@ -56,7 +59,9 @@ export function createResourceCollector({
         if (resourceType === 'image') images.add(path);
         else if (resourceType === 'script') scripts.add(path);
         else if (resourceType === 'stylesheet') styles.add(path);
-        else if (collectJson && isJson(response)) {
+        else if (resourceType === 'font') {
+          fonts.set(path, response.headers()['content-type'] ?? null);
+        } else if (collectJson && isJson(response)) {
           const length = Number(response.headers()['content-length'] ?? Number.NaN);
           if (Number.isFinite(length) && length > maxCachedBytes) return;
           const capture = response

package/src/core/route-config.js

@@ -0,0 +1,17 @@
+import { matchesPattern } from './routes.js';
+
+/**
+ * Resolves one route's effective config by applying matching routeOverrides in order.
+ * Later entries win per key; the base config is never mutated.
+ */
+export function resolveRouteConfig(config, route) {
+  let resolved = config;
+  for (const override of config.routeOverrides ?? []) {
+    if (!matchesPattern(route, override.match)) continue;
+    const values = Object.fromEntries(
+      Object.entries(override).filter(([key, value]) => key !== 'match' && value !== undefined),
+    );
+    resolved = { ...resolved, ...values };
+  }
+  return resolved;
+}

package/src/core/route-sources.js

@@ -0,0 +1,209 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isSafeRoute, normaliseRoute, toAppRoute } from './routes.js';
+
+const MAX_SOURCE_ROUTES = 100000;
+const FETCH_TIMEOUT = 10000;
+const XML_ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+
+/**
+ * Loads concrete route seeds from a text/JSON file and/or a sitemap. These are seeds,
+ * not a router: directory-style app paths still have to be handled by the app.
+ */
+export async function loadRouteSeeds(config) {
+  const routes = [];
+  const sources = [];
+  if (config.routesFile) {
+    const read = await readRouteFile(config.routesFile, config);
+    routes.push(...read.routes);
+    sources.push({
+      source: config.routesFile,
+      type: 'file',
+      routes: read.routes.length,
+      skipped: read.skipped,
+    });
+  }
+  if (config.routesFromSitemap) {
+    const read = await readRouteSitemap(config.routesFromSitemap, config);
+    routes.push(...read.routes);
+    sources.push({
+      source: config.routesFromSitemap,
+      type: 'sitemap',
+      routes: read.routes.length,
+      skipped: read.skipped,
+    });
+  }
+  const unique = [...new Set(routes)];
+  if (unique.length > MAX_SOURCE_ROUTES) {
+    throw new Error(`route sources produced more than ${MAX_SOURCE_ROUTES} routes`);
+  }
+  return { routes: unique, sources };
+}
+
+// Reads a text or JSON route list. Text accepts one route per line and # comments.
+async function readRouteFile(file, config) {
+  const contents = await fs.readFile(path.resolve(file), 'utf8');
+  let values;
+  const trimmed = contents.trim();
+  if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(`routesFile is not valid JSON: ${error.message}`);
+    }
+    values = Array.isArray(parsed) ? parsed : parsed?.routes;
+    if (!Array.isArray(values)) {
+      throw new Error('routesFile JSON must be an array or an object with a routes array');
+    }
+  } else {
+    values = trimmed
+      .split(/\r?\n/)
+      .map((line) => line.replace(/#.*$/, '').trim())
+      .filter((line) => line.length > 0);
+  }
+  return normaliseAndFilter(values, 'routesFile', config);
+}
+
+// Reads a sitemap, following a sitemap index one level deep.
+async function readRouteSitemap(location, config) {
+  const pageUrls = [];
+  await readSitemapLevel(location, pageUrls, 0);
+  const sourceOrigin = /^https?:\/\//i.test(location) ? new URL(location).origin : null;
+  return normaliseAndFilter(pageUrls, 'routesFromSitemap', config, sourceOrigin, true);
+}
+
+async function readSitemapLevel(location, pageUrls, depth) {
+  if (depth > 1) return;
+  const { text, base } = await readSource(location);
+  if (!/<(?:urlset|sitemapindex)\b/i.test(text)) {
+    throw new Error(`${location} is not a sitemap: no urlset or sitemapindex element found`);
+  }
+  if (/<sitemapindex\b/i.test(text)) {
+    for (const child of extractLocs(text)) {
+      await readSitemapLevel(resolveChild(child, base), pageUrls, depth + 1);
+    }
+    return;
+  }
+  pageUrls.push(...extractLocs(text));
+}
+
+// Reads a local path or an http(s) sitemap.
+async function readSource(location) {
+  if (/^https?:\/\//i.test(location)) {
+    const response = await fetch(location, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT),
+      headers: { accept: 'application/xml,text/xml,*/*' },
+    });
+    if (!response.ok) throw new Error(`sitemap ${location} answered HTTP ${response.status}`);
+    return { text: await response.text(), base: location };
+  }
+  const file = path.resolve(location);
+  return { text: await fs.readFile(file, 'utf8'), base: file };
+}
+
+// Resolves a child sitemap location relative to its parent.
+function resolveChild(child, base) {
+  if (/^https?:\/\//i.test(child)) return child;
+  if (/^https?:\/\//i.test(base)) return new URL(child, base).href;
+  return path.resolve(path.dirname(base), child);
+}
+
+// Extracts and unescapes every <loc> value.
+function extractLocs(xml) {
+  const values = [];
+  for (const match of xml.matchAll(/<loc\b[^>]*>([\s\S]*?)<\/loc>/gi)) {
+    values.push(unescapeXml(match[1].trim()));
+  }
+  return values;
+}
+
+function unescapeXml(value) {
+  return value.replace(/&(amp|lt|gt|quot|apos);/g, (_, name) => XML_ENTITIES[name]);
+}
+
+// Converts source values to app-relative routes and drops unsafe or off-origin entries.
+function normaliseAndFilter(
+  values,
+  source,
+  config = null,
+  sourceOrigin = null,
+  enforceOrigin = false,
+) {
+  const siteOrigin = config?.metadata?.siteUrl ? new URL(config.metadata.siteUrl).origin : null;
+  const referenceOrigin = siteOrigin ?? sourceOrigin;
+  const base = config?.base ?? '/';
+  const routes = [];
+  const seen = new Set();
+  let skipped = 0;
+  for (const value of values) {
+    if (typeof value !== 'string') {
+      skipped += 1;
+      continue;
+    }
+    const absolute = parseAbsolute(value, referenceOrigin);
+    if (/^https?:\/\//i.test(value) && !absolute) {
+      skipped += 1;
+      continue;
+    }
+    let route;
+    if (absolute) {
+      if (!referenceOrigin) {
+        if (enforceOrigin) {
+          skipped += 1;
+          continue;
+        }
+      } else if (absolute.origin !== referenceOrigin) {
+        skipped += 1;
+        continue;
+      }
+      route = toAppRoute(absolute.href, base);
+    } else if (value.startsWith('//')) {
+      // A protocol-relative URL needs an origin to resolve against; without one it is
+      // not safe to guess which host it belongs to.
+      skipped += 1;
+      continue;
+    } else {
+      route = normaliseRoute(stripBase(value, base));
+    }
+    if (!route || !isSafeRoute(route) || seen.has(route)) {
+      skipped += 1;
+      continue;
+    }
+    seen.add(route);
+    routes.push(route);
+  }
+  if (routes.length === 0 && values.length > 0) {
+    throw new Error(`${source} did not contain any usable routes`);
+  }
+  return { routes, skipped };
+}
+
+// Resolves an absolute or protocol-relative URL, returning null for paths.
+function parseAbsolute(value, referenceOrigin) {
+  if (/^https?:\/\//i.test(value)) {
+    try {
+      return new URL(value);
+    } catch {
+      return null;
+    }
+  }
+  if (value.startsWith('//') && referenceOrigin) {
+    try {
+      return new URL(value, referenceOrigin);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// Removes the public base prefix from a root-relative path, leaving app-relative paths
+// alone so a sitemap can list either form.
+function stripBase(value, base) {
+  if (base === '/') return value;
+  const prefix = base.slice(0, -1);
+  if (value === prefix) return '/';
+  if (value.startsWith(`${prefix}/`)) return value.slice(prefix.length);
+  return value;
+}

package/src/core/routes.js

@@ -43,6 +43,15 @@ export function matchesPattern(route, pattern) {
 function matchesAny(route, patterns) {
   return patterns.some((pattern) => matchesPattern(route, pattern));
 }
+
+/**
+ * Reports whether a route belongs in the output. An empty pattern list allows every
+ * route; a supplied list is an allowlist for output as well as for discovery, so a
+ * seed used only to reach wildcard routes is not written itself.
+ */
+export function isIncludedRoute(route, patterns = []) {
+  return patterns.length === 0 || matchesAny(route, patterns);
+}
 /**
  * Reports whether a route is safe to map onto the output directory. Literal dot
  * segments are already resolved, so this catches the encoded forms: percent-encoded