@mapled/cli 0.13.0 → 0.14.0

package/README.md

@@ -128,7 +128,7 @@ Scanned 2 HTML files — 2 pages, 11 bindings.
 ⚠ This path names nothing in the schema: home.tagline (index.html). A misspelled field empties its place on the page, a misspelled single leaves the page's own HTML.
 ```
 
-For a Next.js site the scan also records its live updates: `capabilities.realtime` is `true`, with the route in `releaseRoute`, when `<MapledLive />` or `watchRelease` asks — at the default path or one written in the code — a route whose exported `GET` answers with `createReleaseHandler`, and `false` otherwise — `MAPLED.md` then tells the next agent whether open tabs follow Publish. Capabilities aren't part of the integration hash; `doctor`'s Site manifest line says when the pushed ones differ.
+For a Next.js site the scan also records its live updates: `capabilities.realtime` is `true`, with the route in `releaseRoute`, when `<MapledLive />` or `watchRelease` asks — at the default path or one written in the code — a route whose exported `GET` answers with `createReleaseHandler`, or, on the Pages Router, an API route whose default export answers with `createPagesReleaseHandler` (with `<MapledLive />` from `@mapled/next/live/pages` in `pages/_app`), and `false` otherwise — `MAPLED.md` then tells the next agent whether open tabs follow Publish. Capabilities aren't part of the integration hash; `doctor`'s Site manifest line says when the pushed ones differ.
 
 `--write` creates or updates `mapled/manifest.json`. Bindings the scan can't see (written by your AI agent, or by hand) are kept and listed; `--prune` drops them. Commit the file.
 
@@ -204,7 +204,7 @@ Mapled doctor — Dolphin Landing
 1 warning.
 ```
 
-The repository side: the link, the sign-in, the generated types, the schema pin, the site manifest (and whether it matches what was pushed), the integration hash — one line saying whether the pin and the manifest here describe the same integration Mapled holds, and if not, what moved (the schema, the bindings, or edits made in Mapled) and which command catches up — `MAPLED.md` (and whether it is what Mapled would render now), `MAPLED_KEY` and `MAPLED_WEBHOOK_SECRET` in your env files (names only — values are never read out), env files or Mapled secrets tracked by git, the installed `@mapled/next` and CLI versions, the revalidation and preview routes of a Next.js site, and its live updates — ○ «Not used» while no page mounts `<MapledLive />` or calls `watchRelease`, ✓ when the route they ask answers its `GET` with `createReleaseHandler` (`GET` is the handler, or always returns its call: every return is that call, the last statement is one, and nothing throws), ⚠ when it is missing (the tabs would poll a 404) with the file to add, when the route's `GET` isn't seen to answer with the handler (exported as `POST` they would get a 405; a `GET` that only mentions it, calls it and returns something else, or answers something else on another branch, answers without the release), or when no route can be checked against the endpoint — it is relative to the page, a full address (the tab asks it as written, and doctor can't tell it's the site's own), computed, or comes from spread props; a path from the site's root is checked against the route the App Router picks for it, dynamic and catch-all folders included, among route files with the site's page extensions (`pageExtensions` in next.config; `tsx`, `ts`, `jsx`, `js` by default) and under its `basePath`; ⚠ too when a page of either router, more specific than the route, takes that path first, when the dynamic route that answers sets `dynamicParams`, when the route may set `dynamic` to anything but `"auto"` or `"force-dynamic"` (a copy Next builds without the tab's request), sets `"force-dynamic"` while `createReleaseHandler` there isn't seen to keep a `revalidate` above 0 (its default does; with `false` or `0` Next reads the release past the cache tag) or `fetchCache` to anything but `"auto"` (the release read past the cache tag, before the webhook refreshes the pages), when next.config sets `output: "export"` (no server runs the route), or when next.config may set `pageExtensions`, `basePath` or `output` where doctor can't read them — it reads them only as literals, once, in the object the file exports, and only while the file is declarative: type imports, declarations of data, one export of the config object itself, and functions only as Next's hooks (`webpack`, `headers` …) in it. A module the file loads (a plugin such as `withMDX`, a `path` helper, an env check), a config exported as a function, any other code, a spread or a getter leaves the config unread. With a `basePath`, a listener that gives no endpoint asks under it from `@mapled/next` 0.10.0 — doctor reads the version the site has installed, and it's a ⚠ when that is older or missing. A `middleware` file (`proxy` in Next 16) next to the folder Next reads is a ⚠ unless its matcher, read the way Next's build reads `export const config`, surely leaves the route's path alone: it has no matcher, doctor can't read it, a source may take the path, or next.config has locales (`i18n`). `src/app` or `src/pages` counts only when the root has no `app` or `pages`, as Next reads them. doctor reads the files, not how Next serves them at run time: rewrites and what a middleware does on the path aren't checked, and neither is whether a page renders the component that listens; `revalidate` on the route is no ⚠ — the handler's read names its own. The Mapled side, from the same status the AI agent's `check_integration` tool reads: whether the site has read content with the delivery key, the publish webhook and its last delivery, the preview route on the deployed site, the bindings health.
+The repository side: the link, the sign-in, the generated types, the schema pin, the site manifest (and whether it matches what was pushed), the integration hash — one line saying whether the pin and the manifest here describe the same integration Mapled holds, and if not, what moved (the schema, the bindings, or edits made in Mapled) and which command catches up — `MAPLED.md` (and whether it is what Mapled would render now), `MAPLED_KEY` and `MAPLED_WEBHOOK_SECRET` in your env files (names only — values are never read out), env files or Mapled secrets tracked by git, the installed `@mapled/next` and CLI versions, the revalidation and preview routes of a Next.js site, and its live updates — ○ «Not used» while no page mounts `<MapledLive />` or calls `watchRelease`, ✓ when the route they ask answers its `GET` with `createReleaseHandler` (`GET` is the handler, or always returns its call: every return is that call, the last statement is one, and nothing throws), ⚠ when it is missing (the tabs would poll a 404) with the file to add, when the route's `GET` isn't seen to answer with the handler (exported as `POST` they would get a 405; a `GET` that only mentions it, calls it and returns something else, or answers something else on another branch, answers without the release), or when no route can be checked against the endpoint — it is relative to the page, a full address (the tab asks it as written, and doctor can't tell it's the site's own), computed, or comes from spread props; a path from the site's root is checked against the route the App Router picks for it, dynamic and catch-all folders included, among route files with the site's page extensions (`pageExtensions` in next.config; `tsx`, `ts`, `jsx`, `js` by default) and under its `basePath`; ⚠ too when a page of either router, more specific than the route, takes that path first, when the dynamic route that answers sets `dynamicParams`, when the route may set `dynamic` to anything but `"auto"` or `"force-dynamic"` (a copy Next builds without the tab's request), sets `"force-dynamic"` while `createReleaseHandler` there isn't seen to keep a `revalidate` above 0 (its default does; with `false` or `0` Next reads the release past the cache tag) or `fetchCache` to anything but `"auto"` (the release read past the cache tag, before the webhook refreshes the pages), when next.config sets `output: "export"` (no server runs the route), or when next.config may set `pageExtensions`, `basePath` or `output` where doctor can't read them — it reads them only as literals, once, in the object the file exports, and only while the file is declarative: type imports, declarations of data, one export of the config object itself, and functions only as Next's hooks (`webpack`, `headers` …) in it. A module the file loads (a plugin such as `withMDX`, a `path` helper, an env check), a config exported as a function, any other code, a spread or a getter leaves the config unread. With a `basePath`, a listener that gives no endpoint asks under it from `@mapled/next` 0.10.0 — doctor reads the version the site has installed, and it's a ⚠ when that is older or missing. A `middleware` file (`proxy` in Next 16) next to the folder Next reads is a ⚠ unless its matcher, read the way Next's build reads `export const config`, surely leaves the route's path alone: it has no matcher, doctor can't read it, a source may take the path, or next.config has locales (`i18n`). `src/app` or `src/pages` counts only when the root has no `app` or `pages`, as Next reads them. On the Pages Router the route is an API route — a file of the pages folder at `/api` or under it — whose default export is `createPagesReleaseHandler` or always returns its call, and the listener is `<MapledLive />` from `@mapled/next/live/pages` in `pages/_app`: a listener without it gets the API route to add (`pages/api/mapled/release.ts` by default; an endpoint outside `/api` no API route can answer). ⚠ there too when the API route may run on the edge runtime — `runtime` or `config.runtime` other than `"nodejs"`, or written where doctor can't read it (Next reads both only as literals) — where the handler has no Node request and response; when a listener the App Router may run asks it — a file of `app/`, or on a site with both folders one either router may render: the API route answers Mapled's live release, which moves before the webhook refreshes what App Router pages read; and when `<MapledLive />` from `@mapled/next/live/pages` sits in the App Router's folder, where it can't mount. doctor reads the files, not how Next serves them at run time: rewrites and what a middleware does on the path aren't checked, and neither is whether a page renders the component that listens; `revalidate` on the route is no ⚠ — the handler's read names its own. The Mapled side, from the same status the AI agent's `check_integration` tool reads: whether the site has read content with the delivery key, the publish webhook and its last delivery, the preview route on the deployed site, the bindings health.
 
 A site rendered in the visitor's browser — a React single-page app (Vite and the like), plain HTML — is checked for what it has: the package line is `@mapled/react`, Environment wants `VITE_MAPLED_KEY` and no webhook secret, and the routes and the webhook read ○ «Not needed» — such a site shows a publish on its next load and trades Mapled's preview link on the page itself; Live updates reads ○ as well: `live` on `MapledProvider` or `data-mapled-live` asks Mapled directly, with no route of the site's. Plain HTML installs nothing: the line is `@mapled/vanilla`, read from the script tag in the pages (or from a copy of the file next to them) — ⚠ when the address has no version or an older one — and Generated types and Environment read ○: the fields are named in attributes, the delivery key sits in the page. doctor takes the framework from `mapled.json`, or works it out from `package.json` (no `package.json` and an `index.html` is plain HTML). Whatever the framework, a server key or a signing secret under a public prefix (`VITE_…`, `NEXT_PUBLIC_…`) is a ✗: it would ship to every visitor.
 

package/dist/doctor.js

@@ -3,7 +3,7 @@ import { access, readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { integrationHash } from "./integrationHash.js";
-import { BASE_PATH_SINCE, fullAddress, liveState, RELEASE_ROUTE, routeFileFor } from "./live.js";
+import { BASE_PATH_SINCE, fullAddress, liveState, pagesRouteFileFor, RELEASE_ROUTE, routeFileFor, runsIn } from "./live.js";
 import { compareManifests, manifestSummary, MANIFEST_FILE } from "./manifest.js";
 import { SCHEMA_FILE } from "./pin.js";
 import { splitGenerated } from "./types.js";
@@ -467,6 +467,10 @@ export function checkLive(facts, framework) {
     const state = liveState(facts);
     const who = (l) => `${l.via} in ${l.file}`;
     const handler = 'createReleaseHandler from "@mapled/next/server"';
+    // the Pages Router's: the default export of an API route
+    const pagesHandler = 'createPagesReleaseHandler from "@mapled/next/server"';
+    const handlerOf = (route) => (route.router === "pages" ? pagesHandler : handler);
+    const app = `${facts.pagesDir ?? "pages"}/_app`;
     switch (state.kind) {
         case "unused":
             return {
@@ -474,19 +478,46 @@ export function checkLive(facts, framework) {
                 label,
                 status: "skipped",
                 detail: state.handlerRoute
-                    ? `Not used: ${state.handlerRoute.file} is mounted, but no page listens — add <MapledLive /> to the root layout.`
+                    ? state.handlerRoute.router === "pages"
+                        ? `Not used: ${state.handlerRoute.file} is mounted, but no page listens — add <MapledLive /> from "@mapled/next/live/pages" to ${app}.`
+                        : `Not used: ${state.handlerRoute.file} is mounted, but no page listens — add <MapledLive /> to the root layout.`
                     : "Not used: an open tab shows a publish once it is reloaded.",
             };
         case "served":
             return { key, label, status: "passed", detail: `${state.route.file} — open tabs follow Publish (${who(state.listener)})` };
         case "no_handler":
-            return { key, label, status: "warning", detail: `${state.route.file} exists but doesn't use ${handler} — ${who(state.listener)} can't read the release there.` };
+            return { key, label, status: "warning", detail: `${state.route.file} exists but doesn't use ${handlerOf(state.route)} — ${who(state.listener)} can't read the release there.` };
         case "not_get":
             return {
                 key,
                 label,
                 status: "warning",
-                detail: `${state.route.file} calls ${handler}, but doctor can't see its GET always answer with the handler's response — ${who(state.listener)} asks with GET. Export the handler as GET, or end GET by returning its call, with no other return or throw.`,
+                detail: state.route.router === "pages"
+                    ? `${state.route.file} calls ${pagesHandler}, but doctor can't see its default export always answer with the handler, and the default export is what answers ${who(state.listener)}. Export the handler as the default, or end the default function by returning its call, with no other return or throw.`
+                    : `${state.route.file} calls ${handler}, but doctor can't see its GET always answer with the handler's response — ${who(state.listener)} asks with GET. Export the handler as GET, or end GET by returning its call, with no other return or throw.`,
+            };
+        case "router":
+            return {
+                key,
+                label,
+                status: "warning",
+                detail: `${who(state.listener)} comes from "@mapled/next/live/pages", the Pages Router's component, and ${state.dir}/ is the App Router's folder: it can't mount there (it needs next/router), so open tabs don't follow Publish. Import MapledLive from "@mapled/next/live" in the App Router.`,
+            };
+        case "pointer":
+            return {
+                key,
+                label,
+                status: "warning",
+                detail: `${state.route.file} ${state.route.handler === "GET" ? "answers with" : "calls"} ${pagesHandler}, which follows Mapled's live release: it moves the moment someone publishes, before the webhook refreshes what the App Router's pages read. ${who(state.listener)} ${runsIn(state.listener, facts) === "app" ? "runs" : "may run"} in the App Router and would refresh into a release those pages don't show yet. Mount ${handler} at ${routeFileFor(state.path, facts)} in its place — or, if only the Pages Router renders the listener, use <MapledLive /> from "@mapled/next/live/pages" in ${app}.`,
+            };
+        case "runtime":
+            return {
+                key,
+                label,
+                status: "warning",
+                detail: state.runtime === null
+                    ? `${state.route.file} may set runtime where doctor can't read it — Next reads it from export const runtime or export const config = { runtime }, written with literals. On the edge runtime ${pagesHandler} has no Node request and response to answer ${who(state.listener)} through: write runtime as "nodejs", or leave it out.`
+                    : `${state.route.file} sets runtime to ${JSON.stringify(state.runtime)} — ${pagesHandler} answers through Node's request and response, which an API route has only on the Node runtime, so ${who(state.listener)} gets an error there. Leave runtime out of the route, or set it to "nodejs".`,
             };
         case "unresolved":
             return {
@@ -573,7 +604,22 @@ export function checkLive(facts, framework) {
                 detail: `${why}. doctor can't see what it does there — a redirect, a rewrite or a sign-in wall keeps ${who(state.listener)} from the release. Leave the path out of its matcher, like "/((?!${local.slice(1)}).*)".`,
             };
         }
-        case "missing":
+        case "missing": {
+            if (state.pages) {
+                // the Pages Router: an API route, whose default export is the handler
+                const base = facts.basePath ?? "";
+                const file = state.endpoint === null ? null : pagesRouteFileFor(state.endpoint, facts);
+                return {
+                    key,
+                    label,
+                    status: "warning",
+                    detail: state.endpoint === null
+                        ? `${who(state.listener)} asks a release route the code doesn't have — export ${pagesHandler} as the default of an API route (${pagesRouteFileFor(RELEASE_ROUTE, facts)} by default).`
+                        : file !== null
+                            ? `${who(state.listener)} asks ${state.endpoint}, which has no route — export ${pagesHandler} as the default of ${file}.`
+                            : `${who(state.listener)} asks ${state.endpoint}, which has no route — and in the Pages Router only an API route answers it, at ${base}/api or under it. Point it at ${base}${RELEASE_ROUTE}, and export ${pagesHandler} as the default of ${pagesRouteFileFor(`${base}${RELEASE_ROUTE}`, facts)}.`,
+                };
+            }
             return state.endpoint === null
                 ? {
                     key,
@@ -587,6 +633,7 @@ export function checkLive(facts, framework) {
                     status: "warning",
                     detail: `${who(state.listener)} asks ${state.endpoint}, which has no route — mount ${handler} at ${routeFileFor(state.endpoint, facts)}.`,
                 };
+        }
     }
 }
 export function checkReads(lastReadAt) {

package/dist/live.d.ts

@@ -2,13 +2,15 @@
     follows Publish in open tabs with two pieces: `<MapledLive />` from
     "@mapled/next/live" (or `watchRelease` from "@mapled/next") asks a
     route of the site every few seconds, and that route answers with
-    `createReleaseHandler` from "@mapled/next/server". A listener without
-    the route polls a 404 forever and nothing says so — `mapled doctor`
-    reads both and says which is missing, and `mapled scan` records the
-    result in the manifest (`capabilities.realtime`, `releaseRoute`) so
-    MAPLED.md can tell the next agent. The code is read with the scanner's
-    tokenizer: comments and strings never count as a use, and neither
-    does an imported name the file binds again. */
+    `createReleaseHandler` from "@mapled/next/server". The Pages Router
+    has its own two: `<MapledLive />` from "@mapled/next/live/pages", and
+    an API route whose default export is `createPagesReleaseHandler`. A
+    listener without the route polls a 404 forever and nothing says so —
+    `mapled doctor` reads both and says which is missing, and `mapled
+    scan` records the result in the manifest (`capabilities.realtime`,
+    `releaseRoute`) so MAPLED.md can tell the next agent. The code is read
+    with the scanner's tokenizer: comments and strings never count as a
+    use, and neither does an imported name the file binds again. */
 /** Where `<MapledLive />` and `watchRelease` ask when no endpoint is given. */
 export declare const RELEASE_ROUTE = "/api/mapled/release";
 /** The `@mapled/next` from which that default follows the site's basePath —
@@ -23,47 +25,63 @@ export type LiveListener = {
     /** the code gives no endpoint: the SDK asks its default, `endpoint` —
         under the site's basePath from `@mapled/next` 0.10.0 */
     byDefault?: true;
+    /** `<MapledLive />` from "@mapled/next/live/pages": the Pages Router's
+        component, which only the Pages Router can mount (`next/router`) */
+    router?: "pages";
 };
-/** An App Router route handler file and the path it answers. `handler`:
-    "GET" when the route's exported GET is seen to answer with
-    `createReleaseHandler`, "other" when the file calls it but GET isn't
-    (exported as POST or not at all — the tab's GET gets a 405 — or a GET
-    whose answer isn't the handler's), null when it doesn't call it.
-    `params`: the file sets `dynamicParams` — a dynamic route then answers
-    only the params its code lists. `segment`: the first route segment
-    setting the file may export as a value that changes how Next serves or
-    caches the route (SEGMENT_SETTINGS). */
+/** A route file and the path it answers: an App Router route handler
+    file, or a Pages Router API route (`router: "pages"`) — any file of the
+    pages folder whose path is /api or under it. `handler`: "GET" when the
+    tab's GET is seen to reach the release — the App Router route's
+    exported GET answers with `createReleaseHandler`, the API route's
+    default export with `createPagesReleaseHandler` — "other" when the file
+    calls that factory but its answer isn't seen to be the handler's (the
+    App Router handler exported as POST or not at all — the tab's GET gets
+    a 405 — or a GET or a default export that answers something else),
+    null when it doesn't call it. `params`: the file sets `dynamicParams`
+    — a dynamic route then answers only the params its code lists.
+    `segment`: the first route segment setting the file may export as a
+    value that changes how Next serves or caches the route
+    (SEGMENT_SETTINGS). Both are the App Router's; an API route has
+    `runtime` instead: present when the file may run it on another runtime
+    than Node's — the runtime it writes out, or null where the reading
+    can't tell (pagesRuntime). */
 export type RouteFile = {
     file: string;
     path: string;
     handler: RouteHandler;
     params?: true;
     segment?: SegmentSetting;
+    router?: "pages";
+    runtime?: string | null;
 };
 export type RouteHandler = "GET" | "other" | null;
-/** A page file and the path it answers: an App Router `page.<ext>`, or any
-    Pages Router file (`pages/api/…` included). It takes part in the match
-    as Next makes it — a page more specific than a route takes the path. */
+/** A page file and the path it answers: an App Router `page.<ext>`, or a
+    Pages Router page (its API routes are route files). It takes part in
+    the match as Next makes it — a page more specific than a route takes
+    the path. */
 export type PageFile = {
     file: string;
     path: string;
 };
 /** `routeExtension`: what a route file the site lacks would end in — the
-    site's page extension, `ts` by default. `appDir`: the App Router folder
-    Next reads, when the site has one. `basePath`: what every path of the
-    site starts with (next.config). `config`: the next.config file, when it
-    may set `pageExtensions` or `basePath` where the reading can't follow —
-    then no route can be checked. `sdk`: the `@mapled/next` version the
-    site resolves, as Node finds the package from the site's folder up —
-    absent when none is installed. `output`: next.config sets `output:
-    "export"` (value "export") or may set it where the reading can't tell
-    (null) — then there may be no server to run any route. */
+    site's page extension, `ts` by default. `appDir`, `pagesDir`: the App
+    Router and Pages Router folders Next reads, when the site has them.
+    `basePath`: what every path of the site starts with (next.config).
+    `config`: the next.config file, when it may set `pageExtensions` or
+    `basePath` where the reading can't follow — then no route can be
+    checked. `sdk`: the `@mapled/next` version the site resolves, as Node
+    finds the package from the site's folder up — absent when none is
+    installed. `output`: next.config sets `output: "export"` (value
+    "export") or may set it where the reading can't tell (null) — then
+    there may be no server to run any route. */
 export type LiveFacts = {
     listeners: LiveListener[];
     routes: RouteFile[];
     pages?: PageFile[];
     routeExtension?: string;
     appDir?: string;
+    pagesDir?: string;
     basePath?: string;
     config?: string;
     sdk?: string;
@@ -82,6 +100,12 @@ export type Middleware = {
     file: string;
     matcher: string[] | "none" | "unread";
 };
+/** `missing`: `pages` when the listener runs in the Pages Router — the
+    route it lacks is an API route there. `router`: the Pages Router's
+    component in a file of the App Router folder `dir`, where it can't
+    mount. `pointer`: an API route answers with `createPagesReleaseHandler`
+    a listener the App Router may run (runsIn). `runtime`: the API route
+    that answers may run on another runtime than Node's. */
 export type LiveState = {
     kind: "unused";
     handlerRoute: RouteFile | null;
@@ -94,6 +118,21 @@ export type LiveState = {
     kind: "missing";
     listener: LiveListener;
     endpoint: string | null;
+    pages?: true;
+} | {
+    kind: "router";
+    listener: LiveListener;
+    dir: string;
+} | {
+    kind: "pointer";
+    listener: LiveListener;
+    route: RouteFile;
+    path: string;
+} | {
+    kind: "runtime";
+    listener: LiveListener;
+    route: RouteFile;
+    runtime: string | null;
 } | {
     kind: "unresolved";
     listener: LiveListener;
@@ -155,17 +194,19 @@ export type Capabilities = {
 };
 /** The extensions a route file may have when next.config doesn't set `pageExtensions`. */
 export declare const PAGE_EXTENSIONS: string[];
-/** The listeners one file mounts and, for a route file, whether its GET
-    serves the release. An imported name the file binds again — a
-    parameter, a declaration, destructuring — may not be the import where
-    it's used, and the reading can't tell where: none of its uses count.
-    A namespace's name the same: its members count only where `ns` itself
-    is the import. */
-export declare function liveInFile(file: string, text: string): {
+/** The listeners one file mounts and, for a route file of `router`,
+    whether it serves the release: an App Router route through its GET, a
+    Pages API route through its default export. An imported name the file
+    binds again — a parameter, a declaration, destructuring — may not be
+    the import where it's used, and the reading can't tell where: none of
+    its uses count. A namespace's name the same: its members count only
+    where `ns` itself is the import. */
+export declare function liveInFile(file: string, text: string, router?: "app" | "pages"): {
     listeners: LiveListener[];
     handler: RouteHandler;
     params: boolean;
     segment?: SegmentSetting;
+    runtime?: string | null;
 };
 /** The route segment settings that change how Next serves the release
     route or reads what the handler reads, in the order doctor names them:
@@ -252,8 +293,19 @@ export declare function findLive(dir: string, maxFiles?: number): Promise<LiveFa
     — which the code doesn't show to be the site's: `watchRelease` fetches it
     as written, and no route file of this site is known to answer it. */
 export declare const fullAddress: (endpoint: string) => boolean;
+/** Which router runs a listener's code, as far as its file tells: a file
+    of the App Router folder is the App Router's; the Pages Router's
+    `<MapledLive />`, a file of the pages folder, or any file of a site
+    whose only router folder is the pages one — the Pages Router's. Null
+    for anything else: a file either router may render. */
+export declare function runsIn(listener: LiveListener, facts: LiveFacts): "app" | "pages" | null;
 /** Whether every listener has a route that answers it. The first one
-    that doesn't is the one to name. */
+    that doesn't is the one to name. An API route answers with the live
+    release (`createPagesReleaseHandler`), which moves the moment someone
+    publishes: it serves only listeners the Pages Router runs, whose pages
+    read that same release in getServerSideProps (README). A listener the
+    App Router may run refreshes on it before the webhook refreshes what
+    the App Router's pages read, into a release they don't show yet. */
 export declare function liveState(facts: LiveFacts): LiveState;
 /** What `mapled scan` writes into the manifest: a listener nothing answers
     isn't listening; the route is the path the tab asks, not a dynamic route's pattern. */
@@ -262,3 +314,9 @@ export declare function capabilitiesOf(state: LiveState): Capabilities;
     reads — without one, under `src/app` when the site keeps its code there
     — and without the basePath, which Next adds itself. */
 export declare function routeFileFor(endpoint: string, facts: LiveFacts): string;
+/** Where an API route answering `endpoint` goes, for a listener the Pages
+    Router runs: in the pages folder Next reads — without one, under
+    `src/pages` when the site keeps its code there — and without the
+    basePath. Null for a path no API route answers: Next serves them at
+    /api and under it only. */
+export declare function pagesRouteFileFor(endpoint: string, facts: LiveFacts): string | null;

package/dist/live.js

@@ -5,13 +5,15 @@ import { appRoute, listFiles, tokenize } from "./scan.js";
     follows Publish in open tabs with two pieces: `<MapledLive />` from
     "@mapled/next/live" (or `watchRelease` from "@mapled/next") asks a
     route of the site every few seconds, and that route answers with
-    `createReleaseHandler` from "@mapled/next/server". A listener without
-    the route polls a 404 forever and nothing says so — `mapled doctor`
-    reads both and says which is missing, and `mapled scan` records the
-    result in the manifest (`capabilities.realtime`, `releaseRoute`) so
-    MAPLED.md can tell the next agent. The code is read with the scanner's
-    tokenizer: comments and strings never count as a use, and neither
-    does an imported name the file binds again. */
+    `createReleaseHandler` from "@mapled/next/server". The Pages Router
+    has its own two: `<MapledLive />` from "@mapled/next/live/pages", and
+    an API route whose default export is `createPagesReleaseHandler`. A
+    listener without the route polls a 404 forever and nothing says so —
+    `mapled doctor` reads both and says which is missing, and `mapled
+    scan` records the result in the manifest (`capabilities.realtime`,
+    `releaseRoute`) so MAPLED.md can tell the next agent. The code is read
+    with the scanner's tokenizer: comments and strings never count as a
+    use, and neither does an imported name the file binds again. */
 /** Where `<MapledLive />` and `watchRelease` ask when no endpoint is given. */
 export const RELEASE_ROUTE = "/api/mapled/release";
 /** The `@mapled/next` from which that default follows the site's basePath —
@@ -21,16 +23,17 @@ export const BASE_PATH_SINCE = "0.10.0";
 export const PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"];
 // the config files Next reads, in its order
 const NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.mts", "next.config.cjs"];
-// the three names as written, or an escape that may spell one: `import { w\u0061tchRelease as w }`
-const WORDS = /MapledLive|watchRelease|createReleaseHandler|\\u/;
+// the names as written, or an escape that may spell one: `import { w\u0061tchRelease as w }`
+const WORDS = /MapledLive|watchRelease|createReleaseHandler|createPagesReleaseHandler|\\u/;
 /** A member `object.name` as one name among the file's: no identifier
     reads the same. A namespace's `ns.createReleaseHandler` is one — a
     namespace can't be written to, so its member is the import wherever
     `ns` itself is. */
 const memberName = (object, name) => `${object}.${name}`;
-/** The imports of the three exports, and of their modules as namespaces; type-only imports don't count. */
+/** The imports of the exports, and of their modules as namespaces; type-only imports don't count. */
 function importsOf(tokens) {
-    const found = { live: new Set(), watch: new Set(), handler: new Set(), ns: { live: new Set(), watch: new Set(), handler: new Set() } };
+    const names = () => ({ live: new Set(), livePages: new Set(), watch: new Set(), handler: new Set(), pagesHandler: new Set() });
+    const found = { ...names(), ns: names() };
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
         if (t.kind !== "ident" || t.value !== "import")
@@ -73,18 +76,26 @@ function importsOf(tokens) {
         for (const n of names) {
             if (source === "@mapled/next/live" && n.imported === "MapledLive")
                 found.live.add(n.local);
+            if (source === "@mapled/next/live/pages" && n.imported === "MapledLive")
+                found.livePages.add(n.local);
             if (source === "@mapled/next" && n.imported === "watchRelease")
                 found.watch.add(n.local);
             if (source === "@mapled/next/server" && n.imported === "createReleaseHandler")
                 found.handler.add(n.local);
+            if (source === "@mapled/next/server" && n.imported === "createPagesReleaseHandler")
+                found.pagesHandler.add(n.local);
         }
         if (namespace !== null) {
             if (source === "@mapled/next/live")
                 found.ns.live.add(namespace);
+            if (source === "@mapled/next/live/pages")
+                found.ns.livePages.add(namespace);
             if (source === "@mapled/next")
                 found.ns.watch.add(namespace);
-            if (source === "@mapled/next/server")
+            if (source === "@mapled/next/server") {
                 found.ns.handler.add(namespace);
+                found.ns.pagesHandler.add(namespace);
+            }
         }
     }
     return found;
@@ -368,9 +379,44 @@ function declarationsOf(tokens, after) {
                 continue;
             out.push({ name, at: i + 1, exported: exportedAt(i), from: body, to: after[body], fn: true, async: isWord(tokens[i - 1], "async") });
         }
+        else if (t.value === "export" && isWord(tokens[i + 1], "default") && !isPunct(tokens[i - 1], ".")) {
+            const d = defaultExport(tokens, after, i);
+            if (d)
+                out.push(d);
+        }
     }
     return out;
 }
+/** What `export default` at `i` exports, as a declaration named `default`
+    — a reserved word, so no binding of the file reads the same: an
+    expression's value; an anonymous function's body; the name of a named
+    function, which is the binding the module exports (a function
+    declaration the loop above reads too, so writing to that name later
+    changes the default as well). A class, a generator or a type is none. */
+function defaultExport(tokens, after, i) {
+    const at = i + 1;
+    let j = i + 2;
+    const async = isWord(tokens[j], "async") && isWord(tokens[j + 1], "function") && !tokens[j + 1].nl;
+    if (async)
+        j++;
+    if (isWord(tokens[j], "function")) {
+        if (isPunct(tokens[j + 1], "*"))
+            return null;
+        if (tokens[j + 1]?.kind === "ident")
+            return { name: "default", at, exported: true, from: j + 1, to: j + 2, fn: false, async: false };
+        let open = j + 1;
+        while (open < tokens.length && open < j + 50 && !isPunct(tokens[open], "("))
+            open++;
+        if (!isPunct(tokens[open], "("))
+            return null;
+        const body = bodyAfter(tokens, after[open]);
+        return body === null ? null : { name: "default", at, exported: true, from: body, to: after[body], fn: true, async };
+    }
+    if (["class", "abstract", "interface"].some((w) => isWord(tokens[j], w)))
+        return null;
+    const to = initializerEnd(tokens, after, i + 2);
+    return { name: "default", at, exported: true, from: i + 2, to, fn: false, async: false };
+}
 /** The local names an `export { a as GET, b }` clause exports, by exported
     name; re-exports `from` another module don't count — their code is elsewhere. */
 function exportClauses(tokens) {
@@ -725,21 +771,29 @@ function readingOf(tokens) {
     const bound = new Set([...rebound, ...declarations.map((d) => d.name)]);
     return { b, declarations, rebound, bound };
 }
-/** Whether the route's exported GET answers with the release handler:
-    GET is a handler — `export const GET = createReleaseHandler(…)`,
-    `export { release as GET }`, `const GET = make()` — or a function that
-    always returns a handler's response: `export async function GET(req) {
-    return release(req); }`. A GET that only mentions the handler, calls it
-    and drops the result, returns it uncalled (`() => release`), or answers
-    something else on another branch or by a throw doesn't. A name declared
-    more than once, or returned more than once, is what all its values agree on,
-    a name bound or changed any other way is nothing the reading knows,
-    and neither is `createReleaseHandler` where the file binds its name
-    again — or a namespace's `ns.createReleaseHandler` where it binds `ns` again. */
-function releaseHandlerOf(tokens, names, read) {
-    const handlers = names.handler;
+/** The App Router's factory, whose handler a route exports as GET, and the
+    Pages Router's, whose handler an API route exports as its default. */
+const APP_HANDLER = (names) => ({ name: "createReleaseHandler", direct: names.handler, ns: names.ns.handler });
+const PAGES_HANDLER = (names) => ({ name: "createPagesReleaseHandler", direct: names.pagesHandler, ns: names.ns.pagesHandler });
+/** Whether the route's export — `GET` of an App Router route, `default` of
+    a Pages API route — answers with the factory's handler: the export is a
+    handler — `export const GET = createReleaseHandler(…)`, `export { release
+    as GET }`, `const GET = make()`, `export default
+    createPagesReleaseHandler(…)`, `export default release` — or a function
+    that always returns a handler's response: `export async function
+    GET(req) { return release(req); }`, `export default function handler(req,
+    res) { return release(req, res); }`. An export that only mentions the
+    handler, calls it and drops the result, returns it uncalled (`() =>
+    release`), or answers something else on another branch or by a throw
+    doesn't. A name declared more than once, or returned more than once, is
+    what all its values agree on, a name bound or changed any other way is
+    nothing the reading knows, and neither is the factory where the file
+    binds its name again — or a namespace's `ns.createReleaseHandler` where
+    it binds `ns` again. */
+function releaseHandlerOf(tokens, factory, exported, read) {
+    const handlers = factory.direct;
     // `createReleaseHandler(` under a name it's imported as, or `ns.createReleaseHandler(` under a namespace's — not `a.ns.createReleaseHandler(`, a member of something else
-    const member = (k) => tokens[k].value === "createReleaseHandler" && isPunct(tokens[k - 1], ".") && tokens[k - 2]?.kind === "ident" && names.ns.handler.has(tokens[k - 2].value) && !isPunct(tokens[k - 3], ".");
+    const member = (k) => tokens[k].value === factory.name && isPunct(tokens[k - 1], ".") && tokens[k - 2]?.kind === "ident" && factory.ns.has(tokens[k - 2].value) && !isPunct(tokens[k - 3], ".");
     const calls = (k) => (handlers.has(tokens[k].value) || member(k)) && isPunct(tokens[k + 1], "(");
     if (!tokens.some((u, k) => u.kind === "ident" && calls(k)))
         return null;
@@ -782,9 +836,9 @@ function releaseHandlerOf(tokens, names, read) {
         if (!bound.has(h))
             grow(h, 1 << FACTORY);
     // a namespace's member is the factory wherever the namespace is the import; bound again, neither is anything the reading knows
-    for (const ns of names.ns.handler)
+    for (const ns of factory.ns)
         if (!bound.has(ns))
-            grow(memberName(ns, "createReleaseHandler"), 1 << FACTORY);
+            grow(memberName(ns, factory.name), 1 << FACTORY);
     while (queue.length > 0) {
         const [name, bits] = queue.pop();
         for (const [i, term] of readers.get(name) ?? []) {
@@ -800,7 +854,7 @@ function releaseHandlerOf(tokens, names, read) {
             ofValue[i] = ofValue[i] | fresh;
             const d = values[i];
             // a declaration under an import's name — the factory's or its namespace's — is nothing the reading knows either
-            if (handlers.has(d) || names.ns.handler.has(d))
+            if (handlers.has(d) || factory.ns.has(d))
                 continue;
             const counts = agree.get(d) ?? [0, 0, 0];
             agree.set(d, counts);
@@ -817,17 +871,18 @@ function releaseHandlerOf(tokens, names, read) {
         }
     }
     const serves = (name) => ((levels.get(name) ?? 0) & (1 << HANDLER)) !== 0;
-    const direct = serves("GET") && declarations.some((d) => d.name === "GET" && d.exported);
-    const clause = (exportClauses(tokens).get("GET") ?? []).some(serves);
+    const direct = serves(exported) && declarations.some((d) => d.name === exported && d.exported);
+    const clause = (exportClauses(tokens).get(exported) ?? []).some(serves);
     return direct || clause ? "GET" : "other";
 }
-/** The listeners one file mounts and, for a route file, whether its GET
-    serves the release. An imported name the file binds again — a
-    parameter, a declaration, destructuring — may not be the import where
-    it's used, and the reading can't tell where: none of its uses count.
-    A namespace's name the same: its members count only where `ns` itself
-    is the import. */
-export function liveInFile(file, text) {
+/** The listeners one file mounts and, for a route file of `router`,
+    whether it serves the release: an App Router route through its GET, a
+    Pages API route through its default export. An imported name the file
+    binds again — a parameter, a declaration, destructuring — may not be
+    the import where it's used, and the reading can't tell where: none of
+    its uses count. A namespace's name the same: its members count only
+    where `ns` itself is the import. */
+export function liveInFile(file, text, router = "app") {
     const tokens = tokenize(text);
     const names = importsOf(tokens);
     let reading = null;
@@ -839,7 +894,10 @@ export function liveInFile(file, text) {
         return isPunct(tokens[k - 1], ".") && ns?.kind === "ident" && namespaces.has(ns.value) && !isPunct(tokens[k - 3], ".") && !read().bound.has(ns.value);
     };
     const listeners = [];
-    const listener = (via, endpoint) => endpoint === undefined ? { file, via, endpoint: RELEASE_ROUTE, byDefault: true } : { file, via, endpoint };
+    const listener = (via, endpoint, pages = false) => ({
+        ...(endpoint === undefined ? { file, via, endpoint: RELEASE_ROUTE, byDefault: true } : { file, via, endpoint }),
+        ...(pages ? { router: "pages" } : {}),
+    });
     for (let k = 0; k < tokens.length; k++) {
         const t = tokens[k];
         if (t.kind !== "ident")
@@ -849,9 +907,17 @@ export function liveInFile(file, text) {
                 continue;
             listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1)));
         }
+        else if (names.livePages.has(t.value) && isPunct(tokens[k - 1], "<")) {
+            if (read().bound.has(t.value))
+                continue;
+            listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1), true));
+        }
         else if (t.value === "MapledLive" && isPunct(tokens[k - 3], "<") && ofNamespace(k, names.ns.live)) {
             listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1)));
         }
+        else if (t.value === "MapledLive" && isPunct(tokens[k - 3], "<") && ofNamespace(k, names.ns.livePages)) {
+            listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1), true));
+        }
         else if (names.watch.has(t.value) && isPunct(tokens[k + 1], "(") && !isPunct(tokens[k - 1], ".")) {
             const prev = tokens[k - 1];
             if (prev?.kind === "ident" && prev.value === "function")
@@ -864,6 +930,12 @@ export function liveInFile(file, text) {
             listeners.push(listener("watchRelease", callEndpoint(tokens, k + 1)));
         }
     }
+    if (router === "pages") {
+        // an API route: segment config is the App Router's; what may break the handler is the runtime
+        const handler = releaseHandlerOf(tokens, PAGES_HANDLER(names), "default", read);
+        const runtime = handler === null ? undefined : pagesRuntime(tokens, read().b);
+        return { listeners, handler, params: false, ...(runtime !== undefined ? { runtime } : {}) };
+    }
     // `dynamicParams` and the segment settings as the route exports them, or an export the reading can't list
     const listing = tokens.some((u, k) => isWord(u, "exports") || (isWord(u, "export") && isPunct(tokens[k + 1], "*")));
     const sets = (name, keeps) => (listing || tokens.some((u) => isName(u, name))) && setsExport(tokens, read().b.after, name, keeps);
@@ -871,7 +943,7 @@ export function liveInFile(file, text) {
     // "force-dynamic" keeps the route only while the handler's read names its own window (keepsWindow)
     const forced = () => sets("dynamic", (t) => literal(t ?? undefined) && t.value === "auto") && !windowsKept(tokens, names, read().b.after);
     const segment = sets("dynamic", SEGMENT_KEEPS.dynamic) ? "dynamic" : forced() ? "force-dynamic" : sets("fetchCache", SEGMENT_KEEPS.fetchCache) ? "fetchCache" : undefined;
-    return { listeners, handler: releaseHandlerOf(tokens, names, read), params, ...(segment ? { segment } : {}) };
+    return { listeners, handler: releaseHandlerOf(tokens, APP_HANDLER(names), "GET", read), params, ...(segment ? { segment } : {}) };
 }
 /** Whether every release handler the file makes keeps a window of its own
     for the pointer's read (keepsWindow), with the factory only ever called
@@ -954,7 +1026,8 @@ const SEGMENT_KEEPS = {
     fetchCache: (t) => literal(t ?? undefined) && t.value === "auto",
 };
 /** Whether the route may export `name` as anything but a value `keeps`
-    accepts, written out on a `const`. Next reads only the module's
+    accepts, written out on a `const` (`keeps` gets the one token written,
+    and where the declarator's name is). Next reads only the module's
     export: a local variable, a property or a string that says the name is
     nothing to it. An export the reading can't list — `export *`,
     CommonJS — may be it. */
@@ -1003,7 +1076,7 @@ function setsExport(tokens, after, name, keeps) {
             }
             else if (tokens[k].kind === "ident") {
                 // only a `const` keeps its value: a `let` or `var` may change it later
-                if (isName(tokens[k], name) && (declare.value !== "const" || !keeps(writtenValue(tokens, after, k))))
+                if (isName(tokens[k], name) && (declare.value !== "const" || !keeps(writtenValue(tokens, after, k), k)))
                     return true;
                 next = k + 1;
             }
@@ -1930,6 +2003,89 @@ export function middlewareMatcher(text) {
         return "unread";
     return config ?? "none";
 }
+/** The literal a declarator at `at` gives its name as Next's build reads
+    it (extractExportedConstValue): `name = "…"`, a type allowed before the
+    `=` and `satisfies T` after the literal — not `as T`, parentheses or
+    anything else, which Next leaves unread. Null for any other value. */
+function nextLiteral(tokens, after, at) {
+    const eq = isPunct(tokens[at + 1], ":") ? typeEnd(tokens, after, at + 2, tokens.length) : at + 1;
+    if (eq < 0 || !isPunct(tokens[eq], "=") || isPunct(tokens[eq + 1], "="))
+        return null;
+    const v = tokens[eq + 1];
+    if (!literal(v))
+        return null;
+    const end = initializerEnd(tokens, after, eq + 1);
+    let j = eq + 2;
+    if (isWord(tokens[j], "satisfies"))
+        j = typeEnd(tokens, after, j + 1, end);
+    return j === end ? v : null;
+}
+/** The runtime a Pages Router API route runs on, as Next's build reads
+    it (getPagesPageStaticInfo): `export const runtime`, and without it
+    `runtime` in `export const config` — each only as a literal. Undefined
+    for Node's: neither is set, or "nodejs" is written out. The literal
+    when the file writes out another — "edge" or "experimental-edge", where
+    the route gets no Node request and response to write the answer to
+    (any other value fails the build). Null when the file may set one where
+    doctor can't read it: an export it can't list, a value that isn't one
+    plain literal, a spread or a key the code computes in the config. Next
+    leaves what it can't read on Node's, but reads some forms doctor
+    doesn't (a regex elsewhere in the config): doctor calls Node's only
+    what it sees to be. */
+function pagesRuntime(tokens, b) {
+    // `export const runtime = "…"`: it wins over the config's — when Next reads it; one it can't leaves the config's
+    const own = [];
+    const plain = (_, at) => {
+        const t = nextLiteral(tokens, b.after, at);
+        if (t === null)
+            return false;
+        own.push(t.value);
+        return true;
+    };
+    // declared twice, it's the first to Next and the file fails to build: nothing doctor can call Node's
+    if (setsExport(tokens, b.after, "runtime", plain) || own.length > 1)
+        return null;
+    if (own.length === 1)
+        return own[0] === "nodejs" ? undefined : own[0];
+    let runtime = undefined;
+    let declared = -1;
+    for (let i = 0; i < tokens.length; i++) {
+        if (!isWord(tokens[i], "export") || isPunct(tokens[i - 1], ".") || !isWord(tokens[i + 1], "const") || !isWord(tokens[i + 2], "config"))
+            continue;
+        if (declared !== -1)
+            return null;
+        declared = i + 2;
+        let eq = i + 3;
+        if (isPunct(tokens[eq], ":"))
+            eq = typeEnd(tokens, b.after, eq + 1, tokens.length);
+        if (eq < 0 || !isPunct(tokens[eq], "=") || isPunct(tokens[eq + 1], "=") || !isPunct(tokens[eq + 1], "{"))
+            return null;
+        const open = eq + 1;
+        const end = b.after[open];
+        // the statement ends there, or goes on with `satisfies T`
+        const tail = tokens[end];
+        if (tail && !isPunct(tail, ";") && !isPunct(tail, ",") && !isWord(tail, "satisfies") && !(tail.nl === true && tail.kind === "ident"))
+            return null;
+        for (const [a, z] of itemsOf(tokens, b.after, open)) {
+            if (a === z)
+                continue;
+            if (isSpread(tokens, a))
+                return null;
+            const { name, next } = propertyKey(tokens, a);
+            if (name === null)
+                return null;
+            // the last one wins, as in the object; a shorthand, a method or a getter is code
+            if (name === "runtime")
+                runtime = isPunct(tokens[next], ":") && z === next + 2 && literal(tokens[next + 1]) ? tokens[next + 1].value : null;
+        }
+        i = end - 1;
+    }
+    // any other export that may be `config`, as in middlewareMatcher
+    const rest = declared === -1 ? tokens : tokens.map((t, k) => (k === declared ? { ...t, value: "" } : t));
+    if (setsExport(rest, b.after, "config", () => false))
+        return null;
+    return runtime === "nodejs" ? undefined : runtime;
+}
 /** Whether `c` is one of the characters — never for the end of the string. */
 const oneOf = (chars, c) => c !== undefined && c.length === 1 && chars.includes(c);
 // what a path may hold for doctor to place it among a matcher's sources: nothing a URL would encode
@@ -2094,8 +2250,10 @@ export async function findLive(dir, maxFiles = 4000) {
     const routeExtension = extensions === null || extensions.includes("ts") ? "ts" : (extensions[0] ?? "ts");
     // a folder under src/ that Next doesn't read: nothing in it runs
     const rootApp = await atRoot(dir, "app");
-    const ignored = [...(rootApp ? ["src/app/"] : []), ...((await atRoot(dir, "pages")) ? ["src/pages/"] : [])];
+    const rootPages = await atRoot(dir, "pages");
+    const ignored = [...(rootApp ? ["src/app/"] : []), ...(rootPages ? ["src/pages/"] : [])];
     const appDir = rootApp ? "app" : (await atRoot(dir, "src/app")) ? "src/app" : undefined;
+    const pagesDir = rootPages ? "pages" : (await atRoot(dir, "src/pages")) ? "src/pages" : undefined;
     const listeners = [];
     const routes = [];
     const pages = [];
@@ -2104,7 +2262,9 @@ export async function findLive(dir, maxFiles = 4000) {
             continue;
         const route = extensions === null ? null : routeFileOf(file, extensions);
         const page = extensions === null ? null : pageFileOf(file, extensions);
-        if (page !== null)
+        // a Pages Router file whose path is /api or under it is an API route, as Next tells them apart
+        const api = page !== null && /^(?:src\/)?pages\//.test(file) && (page === "/api" || page.startsWith("/api/")) ? page : null;
+        if (page !== null && api === null)
             pages.push({ file, path: page });
         let text;
         try {
@@ -2116,14 +2276,18 @@ export async function findLive(dir, maxFiles = 4000) {
         if (text.length > 2_000_000)
             continue;
         const words = WORDS.test(text);
-        const found = words ? liveInFile(file, text) : { listeners: [], handler: null, params: false };
+        const found = words ? liveInFile(file, text, api !== null ? "pages" : "app") : { listeners: [], handler: null, params: false };
         listeners.push(...found.listeners);
         if (route !== null)
             routes.push({ file, path: route, handler: found.handler, ...(found.params ? { params: true } : {}), ...(found.segment ? { segment: found.segment } : {}) });
+        if (api !== null)
+            routes.push({ file, path: api, handler: found.handler, router: "pages", ...(found.runtime !== undefined ? { runtime: found.runtime } : {}) });
     }
     const facts = { listeners, routes, pages, routeExtension };
     if (appDir)
         facts.appDir = appDir;
+    if (pagesDir)
+        facts.pagesDir = pagesDir;
     if (settings?.basePath)
         facts.basePath = settings.basePath;
     if (settings === null && config)
@@ -2264,8 +2428,26 @@ function answerer(routes, pages) {
 }
 /** Whether a route's folders take a param: `[x]`, `[...x]`, `[[...x]]`. */
 const dynamicRoute = (route) => route.path.split("/").some((s) => segmentRank(s) > 0);
+/** Which router runs a listener's code, as far as its file tells: a file
+    of the App Router folder is the App Router's; the Pages Router's
+    `<MapledLive />`, a file of the pages folder, or any file of a site
+    whose only router folder is the pages one — the Pages Router's. Null
+    for anything else: a file either router may render. */
+export function runsIn(listener, facts) {
+    const under = (dir) => dir !== undefined && listener.file.startsWith(`${dir}/`);
+    if (under(facts.appDir))
+        return "app";
+    if (listener.router === "pages" || under(facts.pagesDir) || (facts.appDir === undefined && facts.pagesDir !== undefined))
+        return "pages";
+    return null;
+}
 /** Whether every listener has a route that answers it. The first one
-    that doesn't is the one to name. */
+    that doesn't is the one to name. An API route answers with the live
+    release (`createPagesReleaseHandler`), which moves the moment someone
+    publishes: it serves only listeners the Pages Router runs, whose pages
+    read that same release in getServerSideProps (README). A listener the
+    App Router may run refreshes on it before the webhook refreshes what
+    the App Router's pages read, into a release they don't show yet. */
 export function liveState(facts) {
     // the conventional path first, then by file: the same answer every run
     const rank = (r) => (r.path === RELEASE_ROUTE ? 0 : 1);
@@ -2276,11 +2458,17 @@ export function liveState(facts) {
     const base = facts.basePath ?? "";
     let served = null;
     for (const listener of facts.listeners) {
+        // the Pages Router's component in the App Router can't mount, whatever it asks
+        if (listener.router === "pages" && facts.appDir !== undefined && listener.file.startsWith(`${facts.appDir}/`))
+            return { kind: "router", listener, dir: facts.appDir };
+        const pagesRun = runsIn(listener, facts) === "pages";
+        // the route it lacks: an API route for a listener the Pages Router runs
+        const missing = (endpoint) => ({ kind: "missing", listener, endpoint, ...(pagesRun ? { pages: true } : {}) });
         if (listener.endpoint === null) {
             // the code decides where it asks: with no release route at all it's
             // surely missing; with one — or routes the reading can't know — nothing says it's the route asked
             if (handlerRoutes.length === 0 && !facts.config)
-                return { kind: "missing", listener, endpoint: null };
+                return missing(null);
             return { kind: "unresolved", listener };
         }
         const written = sitePath(listener.endpoint);
@@ -2303,23 +2491,38 @@ export function liveState(facts) {
             return { kind: "outside", listener, endpoint: at, basePath: base };
         const answer = answerOf(base === "" ? at : at.slice(base.length) || "/");
         if (!answer)
-            return { kind: "missing", listener, endpoint: at };
+            return missing(at);
         if (answer.page) {
             // a page takes the path: through a param, a route of its own at the path wins over it; a route can't share a page's path
             if (answer.ranks.some((r) => r > 0))
-                return { kind: "missing", listener, endpoint: at };
+                return missing(at);
             return { kind: "taken", listener, page: answer.page, endpoint: at };
         }
         const route = answer.route;
         // a dynamic route without the handler: a route of its own at the path wins over the param
-        if (route.handler === null)
-            return dynamicRoute(route) ? { kind: "missing", listener, endpoint: at } : { kind: "no_handler", listener, route };
-        if (route.handler === "other")
-            return { kind: "not_get", listener, route };
-        if (route.params && dynamicRoute(route))
-            return { kind: "params", listener, route, endpoint: at };
-        if (route.segment)
-            return { kind: "segment", listener, route, setting: route.segment };
+        if (route.handler === null && dynamicRoute(route))
+            return missing(at);
+        if (route.router === "pages") {
+            // an API route that isn't the release route is, to a listener the App Router may run, a path taken
+            if (route.handler === null)
+                return pagesRun ? { kind: "no_handler", listener, route } : { kind: "taken", listener, page: { file: route.file, path: route.path }, endpoint: at };
+            if (!pagesRun)
+                return { kind: "pointer", listener, route, path: at };
+            if (route.handler === "other")
+                return { kind: "not_get", listener, route };
+            if (route.runtime !== undefined)
+                return { kind: "runtime", listener, route, runtime: route.runtime };
+        }
+        else {
+            if (route.handler === null)
+                return { kind: "no_handler", listener, route };
+            if (route.handler === "other")
+                return { kind: "not_get", listener, route };
+            if (route.params && dynamicRoute(route))
+                return { kind: "params", listener, route, endpoint: at };
+            if (route.segment)
+                return { kind: "segment", listener, route, setting: route.segment };
+        }
         // middleware runs before the route: whatever it does there, the reading can't see
         for (const m of facts.middleware ?? []) {
             const on = middlewareOn(m, base === "" ? at : at.slice(base.length) || "/", facts.i18n === true);
@@ -2339,8 +2542,24 @@ export function capabilitiesOf(state) {
     reads — without one, under `src/app` when the site keeps its code there
     — and without the basePath, which Next adds itself. */
 export function routeFileFor(endpoint, facts) {
-    const underSrc = [...facts.routes.map((r) => r.file), ...(facts.pages ?? []).map((p) => p.file), ...facts.listeners.map((l) => l.file)].some((f) => f.startsWith("src/"));
+    const local = localPath(endpoint, facts);
+    return `${facts.appDir ?? (underSrc(facts) ? "src/app" : "app")}${local === "/" ? "" : local}/route.${facts.routeExtension ?? "ts"}`;
+}
+/** Where an API route answering `endpoint` goes, for a listener the Pages
+    Router runs: in the pages folder Next reads — without one, under
+    `src/pages` when the site keeps its code there — and without the
+    basePath. Null for a path no API route answers: Next serves them at
+    /api and under it only. */
+export function pagesRouteFileFor(endpoint, facts) {
+    const local = localPath(endpoint, facts);
+    if (local !== "/api" && !local.startsWith("/api/"))
+        return null;
+    return `${facts.pagesDir ?? (underSrc(facts) ? "src/pages" : "pages")}${local === "/api" ? "/api/index" : local}.${facts.routeExtension ?? "ts"}`;
+}
+/** Whether the site keeps its code under src/: some route, page or listener is there. */
+const underSrc = (facts) => [...facts.routes.map((r) => r.file), ...(facts.pages ?? []).map((p) => p.file), ...facts.listeners.map((l) => l.file)].some((f) => f.startsWith("src/"));
+/** An endpoint's path without the basePath, which Next adds itself. */
+function localPath(endpoint, facts) {
     const base = facts.basePath ?? "";
-    const local = base !== "" && (endpoint === base || endpoint.startsWith(`${base}/`)) ? endpoint.slice(base.length) || "/" : endpoint;
-    return `${facts.appDir ?? (underSrc ? "src/app" : "app")}${local === "/" ? "" : local}/route.${facts.routeExtension ?? "ts"}`;
+    return base !== "" && (endpoint === base || endpoint.startsWith(`${base}/`)) ? endpoint.slice(base.length) || "/" : endpoint;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapled/cli",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms, preview drafts and check the site's integration.",
   "license": "MIT",
   "homepage": "https://mapled.io",