prerender-crawler 0.1.0 → 0.2.0

package/dist/sitemap.d.ts

@@ -0,0 +1,56 @@
+import type { PrerenderIntegration, RenderedPage } from "./types.ts";
+/**
+ * The sitemap integration: every rendered page becomes a `<url>` entry.
+ *
+ * The crawl already knows the one thing a sitemap needs and a route
+ * manifest cannot supply — which pages actually exist, dynamic segments
+ * expanded — so the integration is a formatter over `context.pages`.
+ * Pages are dropped when they are redirects, are not HTML, carry a query
+ * (a static host cannot serve them, see `keepQuery`), or ask not to be
+ * indexed (`<meta name="robots" content="noindex">` or an `X-Robots-Tag`
+ * header) — the same signals a search engine would honor on the live site.
+ */
+export type SitemapChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+export interface SitemapEntry {
+    /** Absolute URL of the page. */
+    loc: string;
+    /** Last-modification date, as a `Date` or an already-formatted W3C datetime. */
+    lastmod?: Date | string;
+    changefreq?: SitemapChangeFrequency;
+    /** 0.0 – 1.0 */
+    priority?: number;
+}
+export interface SitemapIntegrationOptions {
+    /**
+     * The site's public origin — `https://example.com`. Sitemap entries are
+     * absolute URLs, and the crawl only knows the loopback origin it
+     * rendered against.
+     */
+    hostname: string;
+    /** @default "sitemap.xml" */
+    filename?: string;
+    /**
+     * Spell entries with a trailing slash (`/about/`) — for hosts that
+     * canonicalize that way. The root is `/` either way.
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /**
+     * Which pages are listed. Runs after the built-in exclusions (redirects,
+     * non-HTML, query spellings, `noindex`); return false to drop more.
+     */
+    filter?(page: RenderedPage): boolean;
+    /**
+     * Per-page metadata — `lastmod`, `changefreq`, `priority` — or a
+     * replacement `loc`. Return nothing to list the page with its URL alone.
+     */
+    entry?(page: RenderedPage): Partial<SitemapEntry> | void;
+}
+export declare function sitemap(options: SitemapIntegrationOptions): PrerenderIntegration;
+/**
+ * Whether a rendered page belongs in a sitemap by the signals the page
+ * itself gives: an HTML document, not a redirect, not a query spelling,
+ * not marked `noindex`.
+ */
+export declare function indexable(page: RenderedPage): boolean;
+export declare function formatSitemap(entries: readonly SitemapEntry[]): string;

package/dist/sitemap.js

@@ -0,0 +1,88 @@
+export function sitemap(options) {
+    const { filename = "sitemap.xml", trailingSlash = false, filter, entry } = options;
+    if (!options.hostname) {
+        throw new Error("sitemap(): `hostname` is required — entries must be absolute URLs");
+    }
+    const hostname = new URL(options.hostname);
+    return {
+        name: "sitemap",
+        teardown(context) {
+            const entries = [];
+            for (const page of context.pages) {
+                if (!indexable(page) || (filter && !filter(page)))
+                    continue;
+                const path = trailingSlash && page.path !== "/" ? `${page.path}/` : page.path;
+                entries.push({ loc: new URL(path, hostname).href, ...entry?.(page) });
+            }
+            entries.sort((a, b) => (a.loc < b.loc ? -1 : a.loc > b.loc ? 1 : 0));
+            context.emitFile({ filename, contents: formatSitemap(entries) });
+        }
+    };
+}
+/**
+ * Whether a rendered page belongs in a sitemap by the signals the page
+ * itself gives: an HTML document, not a redirect, not a query spelling,
+ * not marked `noindex`.
+ */
+export function indexable(page) {
+    if (page.redirect || page.path.includes("?"))
+        return false;
+    if (!(page.response.headers.get("content-type") ?? "").includes("text/html"))
+        return false;
+    if (/\bnoindex\b/i.test(page.response.headers.get("x-robots-tag") ?? ""))
+        return false;
+    return !robotsMeta(page.html).some(content => /\bnoindex\b/i.test(content));
+}
+const META_PATTERN = /<meta\s[^>]*>/gi;
+const ATTRIBUTE = (name) => new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+const NAME = ATTRIBUTE("name");
+const CONTENT = ATTRIBUTE("content");
+/** The `content` of every `<meta name="robots">` in the document's head, any attribute order. */
+function robotsMeta(html) {
+    const head = html.slice(0, headEnd(html));
+    const found = [];
+    for (const [tag] of head.matchAll(META_PATTERN)) {
+        const name = NAME.exec(tag);
+        if (!name || (name[1] ?? name[2] ?? name[3]).trim().toLowerCase() !== "robots")
+            continue;
+        const content = CONTENT.exec(tag);
+        if (content)
+            found.push(content[1] ?? content[2] ?? content[3]);
+    }
+    return found;
+}
+function headEnd(html) {
+    const at = html.search(/<\/head\s*>|<body\b/i);
+    return at === -1 ? html.length : at;
+}
+export function formatSitemap(entries) {
+    const lines = ['<?xml version="1.0" encoding="UTF-8"?>'];
+    lines.push('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
+    for (const entry of entries) {
+        lines.push("  <url>");
+        lines.push(`    <loc>${escapeXml(entry.loc)}</loc>`);
+        if (entry.lastmod !== undefined) {
+            const lastmod = entry.lastmod instanceof Date ? entry.lastmod.toISOString() : String(entry.lastmod);
+            lines.push(`    <lastmod>${escapeXml(lastmod)}</lastmod>`);
+        }
+        if (entry.changefreq)
+            lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);
+        if (entry.priority !== undefined) {
+            lines.push(`    <priority>${clampPriority(entry.priority)}</priority>`);
+        }
+        lines.push("  </url>");
+    }
+    lines.push("</urlset>");
+    return lines.join("\n") + "\n";
+}
+function clampPriority(priority) {
+    return Math.min(1, Math.max(0, priority)).toFixed(1);
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}

package/dist/transports.d.ts

@@ -0,0 +1,35 @@
+import type { Transport } from "./types.ts";
+export interface HttpTransportOptions {
+    /** Headers added to every request (an auth token for a preview deploy, say). */
+    headers?: HeadersInit;
+    /** The fetch implementation to use. @default globalThis.fetch */
+    fetch?: typeof fetch;
+}
+/**
+ * Prerenders a RUNNING server over HTTP: every request the crawl mints is
+ * re-addressed to `target`'s origin (path and query kept) and sent with
+ * `fetch`. Works against anything that speaks HTTP — a framework's preview
+ * server, a container, a staging deploy — with no knowledge of what it is.
+ *
+ * Redirects are delivered to the engine as the 3xx responses the server
+ * sent (`redirect: "manual"`), not followed here: the engine records them,
+ * stubs them, and crawls their targets as pages in their own right.
+ *
+ * Set the run's `origin` to the same value so absolute links in the
+ * rendered HTML count as same-origin — the CLI does this for you.
+ */
+export declare function httpTransport(target: string | URL, options?: HttpTransportOptions): Transport;
+/** A `Request -> Response` handler, as a built server entry exports it. */
+export type RequestHandler = (request: Request) => Response | Promise<Response>;
+/**
+ * Imports a built server module and returns its request handler:
+ * `handleRequest`, `fetch`, or `default.fetch` — the shapes SSR entries and
+ * WinterCG-style servers export.
+ */
+export declare function loadHandler(entry: string | URL): Promise<RequestHandler>;
+/**
+ * Prerenders in-process against a built server module — no HTTP server,
+ * no subprocess: the crawl calls the handler directly. This is what the
+ * Vite plugin drives after the build.
+ */
+export declare function moduleTransport(entry: string | URL): Promise<Transport>;

package/dist/transports.js

@@ -0,0 +1,74 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// The two transports the engine ships. Both are small because the engine's
+// contract is small — `Request` in, `Response` out — and that is the point:
+// anything answering that shape is prerenderable, whether it is a module
+// in this process or a server on the other side of a socket.
+import { pathToFileURL } from "node:url";
+/**
+ * Prerenders a RUNNING server over HTTP: every request the crawl mints is
+ * re-addressed to `target`'s origin (path and query kept) and sent with
+ * `fetch`. Works against anything that speaks HTTP — a framework's preview
+ * server, a container, a staging deploy — with no knowledge of what it is.
+ *
+ * Redirects are delivered to the engine as the 3xx responses the server
+ * sent (`redirect: "manual"`), not followed here: the engine records them,
+ * stubs them, and crawls their targets as pages in their own right.
+ *
+ * Set the run's `origin` to the same value so absolute links in the
+ * rendered HTML count as same-origin — the CLI does this for you.
+ */
+export function httpTransport(target, options = {}) {
+    const base = new URL(target);
+    const send = options.fetch ?? globalThis.fetch;
+    return {
+        async fetch(request) {
+            const url = new URL(request.url);
+            url.protocol = base.protocol;
+            url.host = base.host;
+            const headers = new Headers(request.headers);
+            new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+            return send(new Request(url, { method: request.method, headers, redirect: "manual" }));
+        }
+    };
+}
+/**
+ * Imports a built server module and returns its request handler:
+ * `handleRequest`, `fetch`, or `default.fetch` — the shapes SSR entries and
+ * WinterCG-style servers export.
+ */
+export async function loadHandler(entry) {
+    const href = entry instanceof URL ? entry.href : pathToFileURL(entry).href;
+    let serverModule;
+    try {
+        serverModule = await import(__rewriteRelativeImportExtension(href));
+    }
+    catch (cause) {
+        throw new Error(`prerender could not import the server entry at ${entry}. Prerendering renders pages ` +
+            `through a Request -> Response handler — point it at a module exporting ` +
+            `handleRequest, fetch, or default.fetch.`, { cause });
+    }
+    const handler = serverModule.handleRequest ??
+        serverModule.fetch ??
+        serverModule.default?.fetch;
+    if (typeof handler !== "function") {
+        throw new Error(`The server entry at ${entry} exports none of handleRequest, fetch, or default.fetch — ` +
+            `prerender needs a Request -> Response handler to render pages through.`);
+    }
+    return handler;
+}
+/**
+ * Prerenders in-process against a built server module — no HTTP server,
+ * no subprocess: the crawl calls the handler directly. This is what the
+ * Vite plugin drives after the build.
+ */
+export async function moduleTransport(entry) {
+    const handler = await loadHandler(entry);
+    return { fetch: async (request) => handler(request) };
+}

package/dist/types.d.ts

@@ -36,6 +36,18 @@ export interface PageEntry {
  * shaped `{ path }` is accepted alongside plain strings.
  */
 export type PagesSource = Array<string | PageEntry> | (() => Array<string | PageEntry> | Promise<Array<string | PageEntry>>);
+/**
+ * One redirect the crawl observed: a request for `from` answered 3xx. `to`
+ * is a normalized same-origin path, or an absolute URL when the redirect
+ * leaves the origin. A chain (`/a` -> `/b` -> `/c`) is recorded hop by
+ * hop, one record per path, exactly as a host's redirect rules would
+ * express it.
+ */
+export interface RedirectRecord {
+    from: string;
+    to: string;
+    status: number;
+}
 /** A page the engine rendered (and, when `emitted`, wrote). */
 export interface RenderedPage {
     /** The normalized route path (`/about`), origin and query stripped. */
@@ -52,8 +64,19 @@ export interface RenderedPage {
     emitted: boolean;
     /** The response the transport answered with (body consumed). */
     response: Response;
-    /** The rendered HTML. */
+    /** Milliseconds from the request's start to its body fully read (the successful attempt). */
+    duration: number;
+    /**
+     * The rendered HTML — or, for a redirected path, the meta-refresh stub
+     * that stands in for it (see `redirect`).
+     */
     html: string;
+    /**
+     * Set when the path answered a redirect instead of a page. The stub in
+     * `html` points at the chain's FINAL destination; `redirect` records this
+     * path's own hop. Sitemap tooling should skip these.
+     */
+    redirect?: RedirectRecord;
 }
 /** An extra artifact an integration ships alongside the rendered pages. */
 export interface EmittedFile {
@@ -82,6 +105,19 @@ export interface PrerenderContext {
     mode: PrerenderMode;
     origin: string;
     outDir: string;
+    /** Every page rendered so far — complete by `teardown`. Live view; do not mutate. */
+    pages: readonly RenderedPage[];
+    /** Every redirect observed so far — complete by `teardown`. Live view; do not mutate. */
+    redirects: readonly RedirectRecord[];
+    /** Pages that failed and were skipped (`failOnError: false`) — complete by `teardown`. */
+    skipped: readonly SkippedPage[];
+    /** Files emitted so far by integrations — those before this one, at `teardown`. */
+    files: readonly EmittedFile[];
+    /**
+     * Queues a file to be written with the pages. `filename` is resolved
+     * against the output directory; a `../` or absolute path lands outside
+     * it (a build report that should not deploy, say).
+     */
     emitFile(file: EmittedFile): void;
 }
 /** A hook bundle participating in the run without owning any of it. */
@@ -95,6 +131,14 @@ export interface PrerenderIntegration {
      * produced everything its runtime half will need.
      */
     teardown?(context: PrerenderContext): void | Promise<void>;
+    /**
+     * Declares that this integration turns the run's redirects into the
+     * host's own rules (a `_redirects` file, say). The engine then skips its
+     * meta-refresh stubs at redirected paths: they would be redundant, and on
+     * hosts where an existing file shadows a rule (Netlify) they would
+     * defeat it. Equivalent to `redirectStubs: false` on the run.
+     */
+    handlesRedirects?: boolean;
     /**
      * A module specifier the bundler integration imports for side effects
      * into the CLIENT build when this integration is active — how an
@@ -123,6 +167,18 @@ export interface PrerenderOptions {
     hintHeader?: string;
     /** Drops a discovered path before it is fetched. */
     filter?(path: string): boolean;
+    /**
+     * Treat `/posts?page=2` as a page distinct from `/posts`. Off, the query
+     * is stripped everywhere and one render stands for every spelling. On,
+     * each query spelling renders separately — its links are followed and
+     * its data captured — but is written only when its entry names a
+     * `filename`: a static host serves a path the same regardless of query,
+     * so there is nothing correct to write by default. Meant for hybrid
+     * builds baking per-query data, and for sites that map queries to
+     * files themselves.
+     * @default false
+     */
+    keepQuery?: boolean;
     /** Pages in flight at once. @default 8 */
     concurrency?: number;
     /**
@@ -142,8 +198,16 @@ export interface PrerenderOptions {
      * @default true
      */
     failOnError?: boolean;
-    /** Internal redirect hops followed for one page. @default 5 */
-    maxRedirects?: number;
+    /**
+     * Whether a redirected path gets a meta-refresh stub file pointing at the
+     * chain's final destination, so the old URL keeps working on hosts with
+     * no redirect support of their own. Turn it off when redirects are
+     * expressed as host rules instead (an integration declaring
+     * `handlesRedirects` does so implicitly): a stub file next to a rule is
+     * redundant at best and, on hosts where files shadow rules, defeats it.
+     * @default true unless an integration declares `handlesRedirects`
+     */
+    redirectStubs?: boolean;
     /**
      * Whether rendered pages are written to disk: a blanket policy, or a
      * per-path predicate; per-entry `emit` flags override it either way. A
@@ -173,6 +237,8 @@ export interface SkippedPage {
 /** What a finished run reports. */
 export interface PrerenderResult {
     pages: RenderedPage[];
+    /** Every redirect the crawl observed, one record per redirected path. */
+    redirects: RedirectRecord[];
     /** Extra files integrations emitted. */
     files: EmittedFile[];
     /** Paths that failed and were skipped (only with `failOnError: false`). */

package/dist/vite.d.ts

@@ -1,8 +1,11 @@
 import type { Plugin } from "vite";
-import type { FileRoutePagesOptions } from "./file-routes.ts";
 import type { PrerenderOptions } from "./types.ts";
-export { fileRoutePages, staticRoutePaths } from "./file-routes.ts";
-export type { FileRoutePagesOptions, RouteEntryLike } from "./file-routes.ts";
+export { redirects } from "./redirects.ts";
+export type { RedirectsIntegrationOptions } from "./redirects.ts";
+export { report } from "./report.ts";
+export type { PrerenderReport, ReportIntegrationOptions, ReportPage, ReportSkip } from "./report.ts";
+export { sitemap } from "./sitemap.ts";
+export type { SitemapChangeFrequency, SitemapEntry, SitemapIntegrationOptions } from "./sitemap.ts";
 export type * from "./types.ts";
 /** The `import.meta.env` key the plugin defines with the build's `PrerenderMode`. */
 export declare const PRERENDER_MODE_ENV = "PRERENDER_MODE";
@@ -13,24 +16,13 @@ export interface PrerenderPluginOptions extends PrerenderOptions {
      * Defaults to `server.js` inside the `ssr` environment's output directory.
      */
     serverEntry?: string;
-    /**
-     * Seed the crawl with the static pages of the project's
-     * `filesystem-routing` route directory, merged with `pages`. Dynamic
-     * routes (`/posts/:slug`) are still discovered by links — only a render
-     * knows their values.
-     *
-     * `true` (default) applies when the package and `src/routes` exist and
-     * is silently skipped otherwise; pass options to mirror a customized
-     * `fileRoutes({ dir, extensions })` (then a missing package is an error);
-     * `false` disables it.
-     */
-    fileRoutes?: boolean | FileRoutePagesOptions;
 }
 /**
  * Prerenders the app at build time: crawls the built server handler from
- * `pages` (default `["/"]`, plus the file-routed static pages, plus every
- * same-origin link discovered along the way) and writes each page's HTML —
- * and whatever the integrations emit — into the client output.
+ * `pages` (default `["/"]`, plus every page the server announces on the
+ * hint header, plus every same-origin link discovered along the way) and
+ * writes each page's HTML — and whatever the integrations emit — into the
+ * client output.
  *
  * ```ts
  * import { prerender } from "prerender-crawler/vite";

package/dist/vite.js

@@ -1,21 +1,13 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 // The Vite plugin: `prerender()` from `prerender-crawler/vite`.
 //
-// Framework-agnostic by construction. It knows three things about the app:
-// that `vite build` produces a client output directory, that some
+// Framework-agnostic by construction. It knows two things about the app:
+// that `vite build` produces a client output directory, and that some
 // environment's output includes a module exporting a fetch-shaped handler
-// (`handleRequest` or `fetch`: Request in, Response out), and — optionally
-// — that a `filesystem-routing` directory names the static pages. Anything
+// (`handleRequest` or `fetch`: Request in, Response out). Anything
 // framework-specific rides along as an integration (see
 // `PrerenderIntegration`), the same seam the engine exposes to non-Vite
-// drivers.
+// drivers. Which pages exist is the server's to say — through links and
+// the hint header (see ./announce.ts) — not something read off the disk.
 //
 // Responsibilities, all build-only:
 //
@@ -28,21 +20,20 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 //    environment so runtime code can ask "am I a prerendered build, and of
 //    which kind" — the one bit of client-side knowledge integrations need.
 //    Absent (dev, or a build without this plugin) means "live".
-// 3. Seeding: the static pages of a `filesystem-routing` route directory
-//    seed the crawl automatically, so a page nothing links to still builds.
-import { existsSync } from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
 import { runPrerender } from "./crawl.js";
-import { fileRoutePages, hasFileSystemRouting } from "./file-routes.js";
-export { fileRoutePages, staticRoutePaths } from "./file-routes.js";
+import { moduleTransport } from "./transports.js";
+export { redirects } from "./redirects.js";
+export { report } from "./report.js";
+export { sitemap } from "./sitemap.js";
 /** The `import.meta.env` key the plugin defines with the build's `PrerenderMode`. */
 export const PRERENDER_MODE_ENV = "PRERENDER_MODE";
 /**
  * Prerenders the app at build time: crawls the built server handler from
- * `pages` (default `["/"]`, plus the file-routed static pages, plus every
- * same-origin link discovered along the way) and writes each page's HTML —
- * and whatever the integrations emit — into the client output.
+ * `pages` (default `["/"]`, plus every page the server announces on the
+ * hint header, plus every same-origin link discovered along the way) and
+ * writes each page's HTML — and whatever the integrations emit — into the
+ * client output.
  *
  * ```ts
  * import { prerender } from "prerender-crawler/vite";
@@ -81,23 +72,23 @@ export function prerender(options = {}) {
                 const entry = options.serverEntry
                     ? path.resolve(root, options.serverEntry)
                     : path.join(ssrOut, "server.js");
-                const handleRequest = await loadHandler(entry);
-                const routeSeeds = await fileRouteSeeds(root, options.fileRoutes);
-                const { serverEntry: _entry, fileRoutes: _fileRoutes, pages, ...crawl } = options;
-                const result = await runPrerender({
-                    ...crawl,
-                    mode,
-                    pages: async () => [
-                        ...(typeof pages === "function" ? await pages() : (pages ?? ["/"])),
-                        ...routeSeeds
-                    ],
-                    transport: { fetch: request => handleRequest(request) },
-                    outDir: clientOut
-                });
+                let transport;
+                try {
+                    transport = await moduleTransport(entry);
+                }
+                catch (error) {
+                    throw new Error(`${describe(error)} Prerendering renders pages through the server build — make ` +
+                        `sure an SSR build runs (the server build is a build-time tool here; it need not ` +
+                        `be deployed) or point \`serverEntry\` at the module.`, { cause: error });
+                }
+                const { serverEntry: _entry, ...crawl } = options;
+                const result = await runPrerender({ ...crawl, mode, transport, outDir: clientOut });
                 const written = result.pages.filter(page => page.emitted).length;
-                const seeded = routeSeeds.length ? `, ${routeSeeds.length} seeded from file routes` : "";
-                logger.info(`[prerender] rendered ${result.pages.length} page(s) (${written} written${seeded}), ` +
-                    `${result.files.length} file(s) emitted -> ${path.relative(root, clientOut)}`);
+                const redirected = result.redirects.length
+                    ? `, ${result.redirects.length} redirect(s)`
+                    : "";
+                logger.info(`[prerender] rendered ${result.pages.length} page(s) (${written} written)` +
+                    `${redirected}, ${result.files.length} file(s) emitted -> ${path.relative(root, clientOut)}`);
                 for (const miss of result.skipped) {
                     logger.warn(`[prerender] skipped ${miss.path}: ${describe(miss.error)}`);
                 }
@@ -105,36 +96,4 @@ export function prerender(options = {}) {
         }
     };
 }
-async function loadHandler(entry) {
-    let serverModule;
-    try {
-        serverModule = await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href));
-    }
-    catch (cause) {
-        throw new Error(`prerender could not import the built server entry at ${entry}. Prerendering renders ` +
-            `pages through the server build — make sure an SSR build runs (the server build is a ` +
-            `build-time tool here; it need not be deployed) or point \`serverEntry\` at a module ` +
-            `exporting handleRequest/fetch.`, { cause });
-    }
-    const handler = serverModule.handleRequest ??
-        serverModule.fetch ??
-        serverModule.default?.fetch;
-    if (typeof handler !== "function") {
-        throw new Error(`The server entry at ${entry} exports none of handleRequest, fetch, or default.fetch — ` +
-            `prerender needs a Request -> Response handler to render pages through.`);
-    }
-    return handler;
-}
-async function fileRouteSeeds(root, option) {
-    if (option === false)
-        return [];
-    const explicit = typeof option === "object" ? option : undefined;
-    if (!explicit) {
-        // auto mode: only when the project actually uses file routing
-        const dir = path.resolve(root, "src/routes");
-        if (!hasFileSystemRouting(root) || !existsSync(dir))
-            return [];
-    }
-    return fileRoutePages({ root, ...explicit })();
-}
 const describe = (error) => (error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prerender-crawler",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Framework-agnostic build-time prerendering. Point it at anything fetch-shaped (Request in, Response out) and it crawls the site into static HTML: seeds, link discovery, header hints, redirects, retries, throttling, and an integration seam for build-time data capture. Ships a Vite plugin at prerender-crawler/vite.",
   "license": "MIT",
   "author": "Ryan Carniato",
@@ -30,8 +30,15 @@
     "./vite": {
       "types": "./dist/vite.d.ts",
       "default": "./dist/vite.js"
+    },
+    "./announce": {
+      "types": "./dist/announce.d.ts",
+      "default": "./dist/announce.js"
     }
   },
+  "bin": {
+    "prerender-crawler": "./dist/cli.js"
+  },
   "files": [
     "dist",
     "LICENSE",
@@ -41,20 +48,15 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "filesystem-routing": ">=0.2.0",
     "vite": "^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {
-    "filesystem-routing": {
-      "optional": true
-    },
     "vite": {
       "optional": true
     }
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "filesystem-routing": "0.2.1",
     "typescript": "^5.8.0",
     "vite": "^8.0.0",
     "vitest": "^4.0.0"

package/dist/file-routes.d.ts

@@ -1,35 +0,0 @@
-export interface FileRoutePagesOptions {
-    /** Project root the route dir resolves against. @default process.cwd() */
-    root?: string;
-    /** Route directory, mirroring `fileRoutes({ dir })`. @default "src/routes" */
-    dir?: string;
-    /** Route file extensions, mirroring `fileRoutes({ extensions })`. @default ["js", "jsx", "ts", "tsx"] */
-    extensions?: string[];
-}
-/** The subset of a `filesystem-routing` manifest entry this module reads. */
-export interface RouteEntryLike {
-    path: string;
-    page?: boolean;
-}
-/**
- * The statically addressable page paths of a route manifest: pages whose
- * path has no parameter or catch-all segment, with `(group)` segments
- * stripped the way emission adapters strip them. Pure — the seam the
- * plugin and tests share.
- */
-export declare function staticRoutePaths(entries: readonly RouteEntryLike[]): string[];
-/**
- * A `pages` source scanning a `filesystem-routing` route directory for its
- * static pages. The package is resolved from the project root (it is the
- * APP's dependency), loaded lazily so projects without it pay nothing.
- *
- * ```ts
- * prerender({ pages: fileRoutePages({ dir: "src/pages" }) })
- * ```
- *
- * The `prerender()` plugin applies this automatically (`fileRoutes: true`,
- * the default) when the package and the route directory exist.
- */
-export declare function fileRoutePages(options?: FileRoutePagesOptions): () => Promise<string[]>;
-/** Whether `filesystem-routing` resolves from the project (for the plugin's auto mode). */
-export declare function hasFileSystemRouting(root: string): boolean;