@haystackeditor/cli 0.25.0 → 0.25.1

package/dist/capture/adapters/django.js

@@ -106,6 +106,13 @@ export async function detectDjango(ctx) {
         label: `Django ${version?.version ?? '(unknown version)'}`,
         manifestAdapter: `django@${version?.version ?? 'unknown'}`,
         blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        // The routes come from the source, so whatever stops init placing the tag stops the manifest too.
+        manifestBlocked: blocked.length > 0 ? blocked.join('; ') : null,
+        fromBuild: false,
+        rewriting: null,
+        publishNote: null,
+        buildPublishDirs: () => [],
+        buildNotes: () => [],
         looked: [appFile(ctx, '**/templates/**/*.html'), ...templates.map(file => repoPath(ctx, join(ctx.appDir, file)))],
         staticDir,
         async integrate(tags) {

package/dist/capture/adapters/index.js

@@ -17,6 +17,16 @@ import { detectStaticHtml, detectVite } from './vite.js';
 const DETECTORS = [
     detectNext, detectReactRouter, detectSvelteKit, detectNuxt, detectVite, detectRails, detectDjango,
 ];
+/** The given adapter's view of this directory (what --adapter names), or null when that adapter does not recognize it. */
+export async function detectWith(ctx, id) {
+    for (const detect of [...DETECTORS, detectStaticHtml]) {
+        const detected = await detect(ctx);
+        if (detected?.id === id)
+            return detected;
+    }
+    return null;
+}
+export const ADAPTER_IDS = ['next', 'vite', 'react-router', 'remix', 'sveltekit', 'nuxt', 'rails', 'django', 'static-html'];
 /** The adapter that claims this directory, or null. A directory with no package manifest, Gemfile or manage.py and an
  * index.html is a static site. */
 export async function detectApp(ctx) {

package/dist/capture/adapters/next-build.js

@@ -0,0 +1,113 @@
+/**
+ * What a Next.js production build says about its routes (CAPTURE-V1 rule 4), read after `next build` from its own output,
+ * so wrappers, conditionals and environment-set options (`basePath: process.env.BASE_PATH`, `output: isVercel ? … : …`)
+ * are what this build actually used. Formats as Next 13–16 write them (packages/next/src/build/index.ts,
+ * generate-routes-manifest.ts, shared/lib/router/utils/app-paths.ts):
+ *   <distDir>/routes-manifest.json            { version: 3, basePath, i18n?, rewrites: { beforeFiles, afterFiles, fallback }
+ *                                              (an array before Next 10), staticRoutes, dynamicRoutes, … }
+ *   <distDir>/required-server-files.json      { version: 1, config: the resolved config (pageExtensions, output, assetPrefix,
+ *                                              basePath, i18n, …), appDir, relativeAppDir, files, ignore }
+ *   <distDir>/app-path-routes-manifest.json   { "/(group)/x/[id]/page": "/x/[id]", … } (app router)
+ *   <distDir>/server/app-paths-manifest.json  { "/(group)/x/[id]/page": "app/(group)/x/[id]/page.js", … } (app router)
+ *   <distDir>/server/pages-manifest.json      { "/about": "pages/about.js", "/_app": "pages/_app.js", … } (pages router)
+ *   <distDir>/export-detail.json              { version: 1, outDirectory, success } (export/index.ts): written by a static
+ *                                              export (`output: 'export'`) inside the build, removed by any other build
+ *   <distDir>/BUILD_ID
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+import { isDirectory, isFile } from './files.js';
+/** Next's default pageExtensions (config-shared.ts), in its order of precedence. */
+export const DEFAULT_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js'];
+function json(file) {
+    if (!isFile(file))
+        return null;
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+/** The build directory: .next when it holds a build, else the one top-level directory that does (a custom distDir),
+ * the newest when several do (the build that just ran). */
+function buildDir(appDir) {
+    const holdsBuild = (dir) => isFile(join(dir, 'routes-manifest.json')) && isFile(join(dir, 'BUILD_ID'));
+    if (holdsBuild(join(appDir, '.next')))
+        return join(appDir, '.next');
+    let entries;
+    try {
+        entries = readdirSync(appDir);
+    }
+    catch {
+        return null;
+    }
+    const builds = entries.filter(entry => entry !== 'node_modules').map(entry => join(appDir, entry))
+        .filter(dir => isDirectory(dir) && holdsBuild(dir))
+        .sort((a, b) => statSync(join(b, 'BUILD_ID')).mtimeMs - statSync(join(a, 'BUILD_ID')).mtimeMs);
+    return builds[0] ?? null;
+}
+/** Next's normalizeAppPath: route groups and @slots add no segment, and the trailing /page or /route goes. */
+export function normalizeAppPath(key) {
+    const segments = key.split('/');
+    const kept = segments.filter((segment, index) => segment !== '' && !(segment.startsWith('(') && segment.endsWith(')'))
+        && !segment.startsWith('@') && !((segment === 'page' || segment === 'route') && index === segments.length - 1));
+    return `/${kept.join('/')}`;
+}
+function pageRewrites(rewrites, basePath) {
+    const list = Array.isArray(rewrites) ? rewrites
+        : rewrites && typeof rewrites === 'object'
+            ? ['beforeFiles', 'afterFiles', 'fallback'].flatMap(phase => rewrites[phase] ?? []) : [];
+    return list.filter(rewrite => {
+        if (typeof rewrite.destination !== 'string' || !rewrite.destination.startsWith('/'))
+            return false;
+        // Destinations carry the basePath; API routes, Next's own files and capture's own files (the origin-root routing a
+        // basePath build asks for) are not pages.
+        const path = basePath !== '' && rewrite.destination.startsWith(`${basePath}/`) ? rewrite.destination.slice(basePath.length) : rewrite.destination;
+        if (path === '/api' || ['/api/', '/_next/', '/_haystack/', '/.well-known/haystack-capture/'].some(prefix => path.startsWith(prefix)))
+            return false;
+        // Intercepting routes' own rewrites (matched on the Next-Url header) keep the URL's route.
+        const has = Array.isArray(rewrite.has) ? rewrite.has : [];
+        return !has.some(condition => condition.type === 'header' && typeof condition.key === 'string' && condition.key.toLowerCase() === 'next-url');
+    }).map(rewrite => ({ source: String(rewrite.source), destination: String(rewrite.destination) }));
+}
+/** The app's production build as Next wrote it, or why there is none to read. */
+export function readNextBuild(appDir) {
+    const dir = buildDir(appDir);
+    if (dir === null)
+        return { manual: 'there is no Next.js build output (.next/routes-manifest.json) to read the routes from: run it after `next build`' };
+    const routes = json(join(dir, 'routes-manifest.json'));
+    if (routes === null)
+        return { manual: `${dir} has no routes-manifest.json` };
+    const required = json(join(dir, 'required-server-files.json'));
+    // The export this build wrote (every build removes the file before it exports, and a finished export says success),
+    // wherever it went: out/, or a custom distDir that `output: 'export'` turns into the export directory.
+    const exported = json(join(dir, 'export-detail.json'));
+    const exportPath = exported?.success === true && typeof exported.outDirectory === 'string'
+        ? (isAbsolute(exported.outDirectory) ? exported.outDirectory : join(appDir, exported.outDirectory)) : null;
+    const config = required?.config ?? {};
+    const appPathRoutes = json(join(dir, 'app-path-routes-manifest.json'));
+    const serverAppPaths = json(join(dir, 'server', 'app-paths-manifest.json'));
+    const appPaths = appPathRoutes ?? (serverAppPaths
+        ? Object.fromEntries(Object.keys(serverAppPaths).map(key => [key, normalizeAppPath(key)])) : null);
+    const locales = Array.isArray(routes.i18n?.locales) ? routes.i18n.locales.filter((locale) => typeof locale === 'string') : [];
+    const basePath = typeof routes.basePath === 'string' ? routes.basePath : '';
+    return {
+        dir,
+        basePath,
+        i18n: locales.length > 0 && typeof routes.i18n?.defaultLocale === 'string' ? { locales, defaultLocale: routes.i18n.defaultLocale } : null,
+        pageExtensions: Array.isArray(config.pageExtensions) && config.pageExtensions.every(item => typeof item === 'string')
+            ? config.pageExtensions : DEFAULT_EXTENSIONS,
+        exportDir: exportPath !== null && isDirectory(exportPath) ? relative(appDir, exportPath).split('\\').join('/') : null,
+        assetPrefix: typeof config.assetPrefix === 'string' ? config.assetPrefix : '',
+        appPaths,
+        pages: json(join(dir, 'server', 'pages-manifest.json')),
+        pageRewrites: pageRewrites(routes.rewrites, basePath),
+    };
+}
+/** The URL path the build's static files are served under (assetPrefix may be another origin, whose path still counts). */
+export function staticPathPrefix(assetPrefix) {
+    if (assetPrefix === '')
+        return '';
+    let path = assetPrefix;
+    try {
+        path = new URL(assetPrefix).pathname;
+    }
+    catch { /* a path, not a URL */ }
+    return path.replace(/\/+$/, '');
+}

package/dist/capture/adapters/next.js

@@ -2,27 +2,31 @@
  * Next.js (CAPTURE-V1 rule 8b): app router 13–16, pages router 11–16.
  *
  * Tag: next/script's <Script strategy="lazyOnload">, which loads the file after the page's load event (rule 1), at the
- * end of the root layout's <body> (app router) and in pages/_app (pages router; created when the app has none, as
+ * end of the root layout's <body> (app router; app/layout, or the one layout of a single top-level dynamic segment such as
+ * app/[locale]/layout when the app has no app/layout) and in pages/_app (pages router; created when the app has none, as
  * Next's default App plus the tag); a hybrid app gets both, and a page is only ever served by one of them. Several root
- * layouts (route groups without app/layout) are a manual step. Static output: public/ (served by `next start`, copied
- * by standalone and Vercel builds after the build command, and by static export into out/).
+ * layouts (route groups, several top-level segments) are a manual step.
  *
- * Routes: app router page files ((group) and @slot folders add no segment, intercepting (.) routes and _private folders
- * are not routes of their own); pages router files (api/, _app, _document, _error, 404 and 500 are not pages). Chunks:
- * the JS under <distDir>/static, served at /_next/static/. basePath and i18n put routes under prefixes the manifest
- * cannot publish at or express, so either is a manual step.
+ * Routes come from the production build, never from next.config (next-build.ts): after `next build`, the manifest step
+ * reads the routes, basePath, i18n, rewrites, pageExtensions and assetPrefix the build actually used, so wrapped,
+ * conditional and environment-set configs are right by construction. Each route maps to its page file (route groups and
+ * @slots add no segment; intercepting routes and Next's own /_ entries are not routes of their own). Chunks: the JS under
+ * <distDir>/static/chunks, at the assetPrefix's path. Publication: public/, which every output serves (`next start`,
+ * Vercel, and standalone once the deployer copies public/ beside server.js, as Next's docs say), plus out/ for a static
+ * export. A basePath prefixes every route (Next serves pages only under it); the tag and the manifest are read at the origin
+ * root, so each such build says which two paths the host must route there (buildNotes).
  */
-import { readFileSync } from 'node:fs';
+import { readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { defaultImportNames, importInsertion, indentUnit, lineIndent, parseFile, pathOf, startsLine, unwrapTs, walk } from '../js-ast.js';
+import { configObject, defaultImportNames, importInsertion, indentUnit, lineIndent, parseFile, pathOf, readConfig, startsLine, unwrapTs, walk } from '../js-ast.js';
 import { repoPath, resolveVersion, appFile } from '../project.js';
 import { paramName, ruleFor } from '../route-pattern.js';
 import { nextScriptTags } from '../tag.js';
+import { middlewareRewrites, parseUrlRewrites, URL_REWRITES_QUESTION } from '../url-rewrites.js';
 import { checkedResult, jsxElementsNamed, ourJsxElements, placeTags, reindented } from './jsx-edit.js';
-import { chunkIds, configFile, configValue, filesUnder, isDirectory, isFile } from './files.js';
-const CONFIG_NAMES = ['next.config.js', 'next.config.mjs', 'next.config.ts', 'next.config.cjs', 'next.config.mts'];
-const DEFAULT_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js'];
-const PAGES_SPECIAL = new Set(['_app', '_document', '_error', '_middleware', '404', '500']);
+import { chunkIds, isDirectory, isFile } from './files.js';
+import { DEFAULT_EXTENSIONS, readNextBuild, staticPathPrefix } from './next-build.js';
+const PAGES_RESERVED = new Set(['/_app', '/_document', '/_error', '/_middleware', '/404', '/500']);
 /** A Next.js folder or file name as a pattern segment. */
 export function nextSegment(name) {
     const optionalCatchAll = /^\[\[\.\.\.(.+)\]\]$/.exec(name);
@@ -43,51 +47,62 @@ export function nextSegment(name) {
     catch { /* a name that is not percent-encoding stays as it is */ }
     return { kind: 'literal', value: literal };
 }
-/** The base name of a page-like file (`page`, `layout`, `_app`) for these page extensions, or null. */
-function stemFor(name, extensions) {
-    for (const extension of [...extensions].sort((a, b) => b.length - a.length)) {
-        if (name.endsWith(`.${extension}`))
-            return name.slice(0, -extension.length - 1);
+const CONFIG_FILES = ['next.config.ts', 'next.config.mts', 'next.config.mjs', 'next.config.js', 'next.config.cjs'];
+/** The pageExtensions in effect for tag placement (rule 13: a file Next ignores, or a second _app, must never be what init
+ * writes): the build's; without one, next.config's (Next's default when it sets none); Next's default assumed when the
+ * config is not one init can read at all; a manual step when it sets them in a way init cannot read. */
+function pageExtensions(ctx, build) {
+    if (!('manual' in build))
+        return { list: build.pageExtensions, assumed: null };
+    const file = CONFIG_FILES.map(name => join(ctx.appDir, name)).find(isFile);
+    if (!file)
+        return { list: DEFAULT_EXTENSIONS, assumed: null };
+    const where = repoPath(ctx, file);
+    const ast = parseFile(readFileSync(file, 'utf8'), file);
+    if (!ast || !configObject(ast)) {
+        return { list: DEFAULT_EXTENSIONS, assumed: `${where} is not a config init can read, and there is no build output to read pageExtensions from` };
     }
-    return null;
+    const read = readConfig(ast, ['pageExtensions']);
+    if (read.state === 'absent')
+        return { list: DEFAULT_EXTENSIONS, assumed: null };
+    if (read.state === 'value' && Array.isArray(read.value) && read.value.length > 0 && read.value.every(item => typeof item === 'string')) {
+        return { list: read.value, assumed: null };
+    }
+    return { manual: `${where} sets pageExtensions in a way init cannot read, and there is no build output (\`next build\`) to read them from` };
 }
-export function appRouterRoutes(ctx, appRouter, extensions) {
-    const routes = [];
-    for (const file of filesUnder(appRouter)) {
-        const parts = file.split('/');
-        const name = parts.pop();
-        if (stemFor(name, extensions) !== 'page')
-            continue;
-        const segments = [];
-        let routable = true;
-        for (const folder of parts) {
-            if (folder.startsWith('_') || folder.startsWith('@') || /^\((\.{1,3}|\.\.\)\(\.\.)\)/.test(folder)) {
-                routable = false;
-                break;
-            }
-            if (/^\(.+\)$/.test(folder))
-                continue;
-            segments.push(nextSegment(folder));
-        }
-        if (routable)
-            routes.push({ ...ruleFor(segments), source: repoPath(ctx, join(appRouter, file)) });
+/** The files in `dir` named `<base>.<anything>`. */
+function namedLike(dir, base) {
+    let names;
+    try {
+        names = readdirSync(dir);
     }
-    return routes;
+    catch {
+        return [];
+    }
+    return names.filter(name => name.startsWith(`${base}.`) && isFile(join(dir, name)));
 }
-export function pagesRouterRoutes(ctx, pagesRouter, extensions) {
-    const routes = [];
-    for (const file of filesUnder(pagesRouter)) {
-        const stem = stemFor(file, extensions);
-        if (stem === null)
-            continue;
-        const parts = stem.split('/');
-        if (parts[0] === 'api' || (parts.length === 1 && PAGES_SPECIAL.has(parts[0])))
-            continue;
-        if (parts[parts.length - 1] === 'index')
-            parts.pop();
-        routes.push({ ...ruleFor(parts.map(nextSegment)), source: repoPath(ctx, join(pagesRouter, file)) });
+/** The one file `<base>.<extension>` in `dir` for the app's pageExtensions (layout.tsx, _app.page.jsx: Next's own rule,
+ * so with known extensions layout.test.tsx, layout.stories.tsx or layout.d.ts are not layouts), null when there is none,
+ * or a manual step when there are several, or when the extensions are assumed and another `<base>.*` file exists. */
+function entryFile(ctx, dir, base, extensions) {
+    const named = namedLike(dir, base);
+    const found = extensions.list.map(extension => `${base}.${extension}`).filter(name => named.includes(name));
+    if (found.length > 1)
+        return { manual: `${repoPath(ctx, dir)} has several ${base} files (${found.join(', ')})` };
+    const others = named.filter(name => !found.includes(name));
+    if (extensions.assumed !== null && others.length > 0) {
+        return { manual: `${repoPath(ctx, dir)} has ${others.join(', ')}, which Next may use as its ${base} (${extensions.assumed})` };
     }
-    return routes;
+    return found.length === 1 ? join(dir, found[0]) : null;
+}
+/** The page file of a build entry: `<dir>/<base>.<ext>` for the build's pageExtensions, in Next's order of precedence. */
+function pageFile(dir, base, extensions) {
+    for (const extension of extensions) {
+        const file = join(dir, `${base}.${extension}`);
+        if (isFile(file))
+            return file;
+    }
+    return null;
 }
 /** The import style of the file: its first import's quote and whether statements end with semicolons. */
 function importStyle(ast, code) {
@@ -120,27 +135,67 @@ function scriptImport(ast, code, site) {
     return { name, components: [...components, name],
         edit: { start: at.at, end: at.at, text: `${at.before}import ${name} from ${quote}next/script${quote}${semicolon}${at.after}` } };
 }
-async function rootLayoutEdit(appRouter, extensions, tags) {
-    const layout = extensions.map(extension => join(appRouter, `layout.${extension}`)).find(isFile);
-    if (!layout) {
-        const groupLayouts = filesUnder(appRouter).filter(file => /^\([^/]+\)\/layout\.[a-z.]+$/.test(file));
-        return { manual: groupLayouts.length > 1
-                ? `the app router has several root layouts (${groupLayouts.map(file => `app/${file}`).join(', ')}), each needing the tag`
-                : 'the app router has no root layout (app/layout)' };
+/** The app router's root layout: app/layout, else the one layout of a single top-level dynamic segment
+ * (app/[locale]/layout, which renders <html> for every page under it) when nothing else is a root layout. */
+function rootLayout(ctx, appRouter, extensions) {
+    const own = entryFile(ctx, appRouter, 'layout', extensions);
+    if (own !== null)
+        return own;
+    let entries;
+    try {
+        entries = readdirSync(appRouter);
+    }
+    catch {
+        entries = [];
+    }
+    const candidates = [];
+    const groups = [];
+    for (const entry of entries) {
+        if (!isDirectory(join(appRouter, entry)))
+            continue;
+        const layoutFile = entryFile(ctx, join(appRouter, entry), 'layout', extensions);
+        if (layoutFile === null)
+            continue;
+        if (typeof layoutFile !== 'string')
+            return layoutFile;
+        if (/^\[[^.[\]]+\]$/.test(entry))
+            candidates.push(layoutFile);
+        else if (/^\(.+\)$/.test(entry))
+            groups.push(layoutFile);
     }
+    if (candidates.length === 1 && groups.length === 0)
+        return candidates[0];
+    const all = [...candidates, ...groups].map(file => file.slice(appRouter.length + 1));
+    return { manual: all.length > 1
+            ? `the app router has several root layouts (${all.map(file => `app/${file}`).join(', ')}), each needing the tag`
+            : 'the app router has no root layout (app/layout, or one under a single top-level dynamic segment)' };
+}
+async function rootLayoutEdit(ctx, appRouter, tags, extensions) {
+    const layout = rootLayout(ctx, appRouter, extensions);
+    if (typeof layout !== 'string')
+        return layout;
     const code = readFileSync(layout, 'utf8');
     const ast = parseFile(code, layout);
     if (!ast)
         return { manual: `${layout} does not parse` };
+    // The <body> that renders the pages: the one with the layout's children in it (a branch that renders an empty body,
+    // like Umami's DISABLE_UI, shows no page to record).
     const bodies = jsxElementsNamed(ast, 'body');
-    if (bodies.length !== 1 || !bodies[0].closingElement) {
-        return { manual: `the root layout has ${bodies.length} <body> elements, not one with children` };
+    const rendering = bodies.filter(body => {
+        let renders = false;
+        walk(body, node => { if (node.type === 'Identifier' && node.name === 'children')
+            renders = true; });
+        return renders && body.closingElement;
+    });
+    const body = bodies.length === 1 && bodies[0].closingElement ? bodies[0] : rendering.length === 1 ? rendering[0] : null;
+    if (!body) {
+        return { manual: `the root layout has ${bodies.length} <body> elements and ${rendering.length} of them render its children, not one` };
     }
-    const script = scriptImport(ast, code, bodies[0]);
+    const script = scriptImport(ast, code, body);
     if ('manual' in script)
         return script;
     const rendered = nextScriptTags(tags, script.name);
-    const edits = placeTags(code, ourJsxElements(ast, script.components), bodies[0].closingElement.start, rendered, indentUnit(code));
+    const edits = placeTags(code, ourJsxElements(ast, script.components), body.closingElement.start, rendered, indentUnit(code));
     if ('manual' in edits)
         return edits;
     if (edits.length === 0)
@@ -204,11 +259,27 @@ ${rendered}    </>
 }
 `;
 }
-async function pagesAppEdit(ctx, pagesRouter, extensions, tags) {
-    const app = extensions.map(extension => join(pagesRouter, `_app.${extension}`)).find(isFile);
+async function pagesAppEdit(ctx, pagesRouter, tags, extensions) {
+    const app = entryFile(ctx, pagesRouter, '_app', extensions);
+    if (app !== null && typeof app !== 'string')
+        return app;
     if (!app) {
+        // Never a second App: with any _app.* there (one Next may use, or a duplicate-page build error to come), the tag is
+        // a manual step.
+        const existing = namedLike(pagesRouter, '_app');
+        if (existing.length > 0) {
+            return { manual: `${repoPath(ctx, pagesRouter)} has ${existing.join(', ')}, none of which is pages/_app for the pageExtensions (${extensions.list.join(', ')}), and init never creates a second App` };
+        }
+        // Nor one under extensions it only assumes (Next would ignore a file outside its pageExtensions).
+        if (extensions.assumed !== null)
+            return { manual: `the app has no pages/_app, and init cannot tell which extension Next would load a new one with (${extensions.assumed})` };
+        // A new pages/_app under an extension the app's pageExtensions include (Next ignores any other).
         const typescript = isFile(join(ctx.appDir, 'tsconfig.json'));
-        return { target: join(pagesRouter, typescript ? '_app.tsx' : '_app.jsx'), content: newApp('Script', tags, typescript) };
+        const list = extensions.list;
+        const extension = list.find(item => item.endsWith(typescript ? 'tsx' : 'jsx')) ?? (typescript ? null : list.find(item => item.endsWith('js')));
+        if (!extension)
+            return { manual: `the app has no pages/_app, and its pageExtensions (${list.join(', ')}) have none for a JSX file init could create` };
+        return { target: join(pagesRouter, `_app.${extension}`), content: newApp('Script', tags, typescript) };
     }
     const code = readFileSync(app, 'utf8');
     const ast = parseFile(code, app);
@@ -250,6 +321,90 @@ async function pagesAppEdit(ctx, pagesRouter, extensions, tags) {
     const result = checkedResult(code, app, script.edit ? [...edits, script.edit] : edits, script.components, rendered);
     return typeof result === 'string' ? { target: app, content: result } : result;
 }
+function formatRewrites(rewrites) {
+    return `${rewrites.slice(0, 3).map(rewrite => `${rewrite.source} -> ${rewrite.destination}`).join(', ')}${rewrites.length > 3 ? ', …' : ''}`;
+}
+function literals(path) {
+    return path.split('/').filter(part => part !== '').map((value) => ({ kind: 'literal', value }));
+}
+/** The routes this production build serves, each with its page file; manual when the build says something the manifest
+ * cannot express exactly or the user's answer about rewrites is missing. */
+function buildRoutes(ctx, appRouter, pagesRouter, build, middleware, answer) {
+    const rewrites = answer ? parseUrlRewrites(answer) : null;
+    if (middleware.kind === 'unknown' && !rewrites)
+        return { manual: `${middleware.why}. ${URL_REWRITES_QUESTION}` };
+    const hiddenName = middleware.kind === 'unknown' && rewrites?.kind === 'hidden-segment' ? rewrites.name : null;
+    if (build.pageRewrites.length > 0) {
+        const listed = formatRewrites(build.pageRewrites);
+        if (!rewrites)
+            return { manual: `next.config rewrites page URLs (${listed}). ${URL_REWRITES_QUESTION}` };
+        // The answer covers rewrites init cannot read; next-intl's middleware init reads itself, so there it is about
+        // next.config's rewrites alone, which add no segment.
+        if (middleware.kind === 'locale-prefix' && rewrites.kind !== 'none') {
+            return { manual: `init reads ${middleware.where} as next-intl's middleware itself, so the answer is about next.config's page rewrites (${listed}) alone:`
+                    + ' `--url-rewrites none` when they never make a page\'s URL show another page' };
+        }
+        // A rewrite into or out of the hidden segment makes URLs show it, or another route's path under it.
+        const param = hiddenName === null ? null : new RegExp(`(^|/):${hiddenName}(?![A-Za-z0-9_])`);
+        const touching = param ? build.pageRewrites.filter(rewrite => param.test(rewrite.source) || param.test(rewrite.destination)) : [];
+        if (touching.length > 0) {
+            return { manual: `next.config rewrites into or out of the hidden [${hiddenName}] segment (${formatRewrites(touching)}), so those URLs show`
+                    + ' paths the route manifest cannot follow' };
+        }
+    }
+    // next-intl (never, as-needed): the locale's segment is the app router's one top-level dynamic segment.
+    const intl = middleware.kind === 'locale-prefix' && middleware.mode !== 'always' ? middleware : null;
+    let localeSegment = hiddenName === null ? null : `[${hiddenName}]`;
+    if (intl) {
+        const firsts = new Set(Object.values(build.appPaths ?? {}).map(path => path.split('/').filter(part => part !== '')[0])
+            .filter((part) => part !== undefined && /^\[[^.[\]]+\]$/.test(part)));
+        if (firsts.size !== 1) {
+            return { manual: `${intl.where} uses next-intl's middleware with localePrefix ${intl.mode}, and the app router has ${firsts.size === 0 ? 'no'
+                    : `several (${[...firsts].join(', ')})`} top-level dynamic segment for the locale` };
+        }
+        localeSegment = [...firsts][0];
+    }
+    const base = literals(build.basePath);
+    const routes = [];
+    const add = (path, source, rank, entry) => {
+        const parts = path.split('/').filter(part => part !== '');
+        // The URL forms of the path: without the hidden segment (an answer, or next-intl's `never`), and for `as-needed`
+        // without it for the default locale and under each other locale's prefix.
+        const forms = localeSegment === null || parts[0] !== localeSegment ? [parts.map(nextSegment)]
+            : [parts.slice(1).map(nextSegment), ...(intl?.mode === 'as-needed' ? intl.locales.filter(locale => locale !== intl.defaultLocale)
+                    .map(locale => [...literals(intl.prefixes[locale] ?? `/${locale}`), ...parts.slice(1).map(nextSegment)]) : [])];
+        for (const segments of forms) {
+            routes.push(source === null ? { match: '/', source: entry, inexact: `no page file for ${entry} was found` }
+                : { ...ruleFor([...base, ...segments]), source: repoPath(ctx, source), rank });
+        }
+    };
+    for (const [entry, path] of Object.entries(build.appPaths ?? {})) {
+        if (!entry.endsWith('/page') || !appRouter)
+            continue;
+        const folders = entry.split('/').slice(1, -1);
+        // Next's own entries (/_not-found, /_global-error), @slot pages (they render beside the page of the same URL) and
+        // intercepting routes (a client navigation's view of another route, whose URL it keeps) are not routes of their own.
+        if (path.startsWith('/_') || folders.some(folder => folder.startsWith('@') || /^\((\.{1,3}|\.\.\)\(\.\.)\)/.test(folder)))
+            continue;
+        add(path, pageFile(join(appRouter, ...folders), 'page', build.pageExtensions), 0, `app${entry}`);
+    }
+    for (const page of Object.keys(build.pages ?? {})) {
+        if (!pagesRouter || PAGES_RESERVED.has(page) || page === '/api' || page.startsWith('/api/') || page.startsWith('/_'))
+            continue;
+        // With i18n, statically generated pages are listed once per locale too (/fr/about); the page is /about.
+        const parts = page.split('/').filter(part => part !== '');
+        if (build.i18n && parts.length > 0 && build.i18n.locales.includes(parts[0]))
+            continue;
+        const base = parts.length === 0 ? 'index' : parts[parts.length - 1];
+        const dir = join(pagesRouter, ...parts.slice(0, -1));
+        const source = pageFile(dir, base, build.pageExtensions) ?? pageFile(join(dir, base), 'index', build.pageExtensions);
+        add(page, source, 0, `pages${page}`);
+        // i18n (pages router): the default locale serves the page without a prefix, and every locale with one.
+        for (const locale of build.i18n?.locales ?? [])
+            add(`/${locale}${page === '/' ? '' : page}`, source, 0, `pages${page}`);
+    }
+    return routes;
+}
 export async function detectNext(ctx) {
     const version = resolveVersion(ctx, 'next');
     if (!version)
@@ -260,50 +415,39 @@ export async function detectNext(ctx) {
     const pagesRouter = isDirectory(join(base, 'pages')) ? join(base, 'pages') : null;
     if (!appRouter && !pagesRouter)
         return null;
-    const config = configFile(ctx.appDir, CONFIG_NAMES);
-    const configName = config.file ? repoPath(ctx, config.file) : appFile(ctx, 'next.config.*');
     const routers = [appRouter && 'app router', pagesRouter && 'pages router'].filter(Boolean).join(' and ');
-    const looked = [appRouter && repoPath(ctx, join(appRouter, 'layout.*')), pagesRouter && repoPath(ctx, join(pagesRouter, '_app.*')),
-        configName].filter((item) => Boolean(item));
-    const blocked = [];
+    const looked = [appRouter && repoPath(ctx, join(appRouter, 'layout.*')), pagesRouter && repoPath(ctx, join(pagesRouter, '_app.*'))]
+        .filter((item) => Boolean(item));
     const supported = appRouter ? [13, 14, 15, 16] : [11, 12, 13, 14, 15, 16];
-    if (version.major === null || !supported.includes(version.major)) {
-        blocked.push(`init knows Next.js ${supported[0]}–${supported[supported.length - 1]} for the ${routers}, and this app's version is ${version.version} (${version.from})`);
-    }
-    const basePath = configValue(config, ['basePath']);
-    if (basePath.state === 'unreadable') {
-        blocked.push(`${configName} is not a config init can read (it may set basePath, which would put the app under a prefix)`);
-    }
-    else if (basePath.state === 'value' && basePath.value !== '') {
-        blocked.push(`${configName} sets basePath ${String(basePath.value)}: the route manifest must be published at the origin root (/.well-known/haystack-capture/), outside the base path`);
-    }
-    if (pagesRouter && configValue(config, ['i18n']).state !== 'absent') {
-        blocked.push(`${configName} sets i18n: pages are served under locale prefixes the route manifest cannot express`);
-    }
-    const extensionsRead = configValue(config, ['pageExtensions']);
-    const extensions = extensionsRead.state === 'value' && Array.isArray(extensionsRead.value) && extensionsRead.value.every(item => typeof item === 'string')
-        ? extensionsRead.value : DEFAULT_EXTENSIONS;
-    if (extensionsRead.state === 'unreadable')
-        blocked.push(`${configName} sets pageExtensions in a way init cannot read`);
-    const output = configValue(config, ['output']);
-    const distDirRead = configValue(config, ['distDir']);
-    if (output.state === 'unreadable')
-        blocked.push(`${configName} sets output in a way init cannot read`);
-    const exported = output.state === 'value' && output.value === 'export';
-    if (exported && distDirRead.state !== 'absent')
-        blocked.push(`${configName} combines output: 'export' with distDir, so where the export lands is not certain`);
-    const distDir = distDirRead.state === 'value' && typeof distDirRead.value === 'string' ? distDirRead.value : '.next';
+    const blocked = version.major === null || !supported.includes(version.major)
+        ? `init knows how Next.js ${supported[0]}–${supported[supported.length - 1]} load scripts for the ${routers}, and this app's version is ${version.version} (${version.from})`
+        : null;
+    const middleware = middlewareRewrites(ctx);
     const scripts = ctx.pkg?.scripts ?? {};
+    let build = null;
+    const readBuild = () => (build ??= readNextBuild(ctx.appDir));
+    const intlNote = middleware.kind === 'locale-prefix' ? ` It reads ${middleware.where} as next-intl's middleware (localePrefix`
+        + ` ${middleware.mode}${middleware.mode === 'as-needed' ? `: ${middleware.defaultLocale}'s URLs have no locale segment` : ''}).` : '';
     return {
         id: 'next',
         label: `Next.js ${version.version} (${routers})`,
         manifestAdapter: `next@${version.version}`,
-        blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        blocked,
+        manifestBlocked: null,
+        fromBuild: true,
+        rewriting: middleware.kind === 'unknown' ? middleware.why : null,
+        publishNote: 'Next.js: each build writes the route manifest into public/, which next start and Vercel serve; with output: \'standalone\','
+            + ' copy public/ beside server.js as Next\'s deployment docs say (the manifest goes with it); a static export gets it too. A build with a'
+            + ` basePath says which two paths to route at the origin root.${intlNote}`,
         looked,
         staticDir: 'public',
         async integrate(tags) {
+            const extensions = pageExtensions(ctx, readBuild());
+            if ('manual' in extensions)
+                return extensions;
             const edits = [];
-            for (const edit of [appRouter && await rootLayoutEdit(appRouter, extensions, tags), pagesRouter && await pagesAppEdit(ctx, pagesRouter, extensions, tags)]) {
+            for (const edit of [appRouter && await rootLayoutEdit(ctx, appRouter, tags, extensions),
+                pagesRouter && await pagesAppEdit(ctx, pagesRouter, tags, extensions)]) {
                 if (!edit)
                     continue;
                 if ('manual' in edit)
@@ -313,15 +457,38 @@ export async function detectNext(ctx) {
             return edits;
         },
         manualTag: tags => [
-            `In the root layout (app/layout, inside <body>) and/or pages/_app, with \`import Script from 'next/script';\`:`,
+            `In the root layout (${appRouter ? repoPath(ctx, join(appRouter, 'layout.tsx')) : 'app/layout.tsx'} or the one that renders <html>, inside <body>)`
+                + ' and/or pages/_app, with `import Script from \'next/script\';`:',
             ...nextScriptTags(tags, 'Script'),
         ],
         build: typeof scripts.build === 'string' ? { kind: 'package-script', script: 'build', phase: 'after' }
             : { manual: `${appFile(ctx, 'package.json')} has no build script to publish the route manifest after` },
-        async routes() {
-            return [...(appRouter ? appRouterRoutes(ctx, appRouter, extensions) : []), ...(pagesRouter ? pagesRouterRoutes(ctx, pagesRouter, extensions) : [])];
+        async routes(inputs) {
+            const current = readBuild();
+            return 'manual' in current ? current : buildRoutes(ctx, appRouter, pagesRouter, current, middleware, inputs.urlRewrites);
+        },
+        chunks() {
+            const current = readBuild();
+            if ('manual' in current)
+                return [];
+            // Next serves its files under the assetPrefix when one is set, else under the basePath.
+            const prefix = current.assetPrefix !== '' ? staticPathPrefix(current.assetPrefix) : current.basePath;
+            return chunkIds(join(current.dir, 'static', 'chunks'), `${prefix}/_next/static/chunks/`);
+        },
+        publishDirs: ['public'],
+        buildPublishDirs() {
+            const current = readBuild();
+            return 'manual' in current || current.exportDir === null ? [] : [current.exportDir];
+        },
+        buildNotes() {
+            const current = readBuild();
+            if ('manual' in current || current.basePath === '')
+                return [];
+            const base = current.basePath;
+            return [`this build serves the app under basePath ${base}, so Next serves public/ at ${base}/, and the tag (/_haystack/) and the route`
+                    + ` manifest (/.well-known/haystack-capture/) are read at the origin root: route those two paths to ${base}/_haystack/ and`
+                    + ` ${base}/.well-known/haystack-capture/ (on the host in front of the app, or with next.config rewrites marked basePath: false);`
+                    + ' until then the tag records nothing'];
         },
-        chunks: () => (distDirRead.state === 'unreadable' ? [] : chunkIds(join(ctx.appDir, distDir, 'static'), '/_next/static/')),
-        publishDirs: exported ? ['out'] : ['public'],
     };
 }

package/dist/capture/adapters/nuxt.js

@@ -161,6 +161,13 @@ export async function detectNuxt(ctx) {
         label: `Nuxt ${version.version}`,
         manifestAdapter: `nuxt@${version.version}`,
         blocked: blocked.length > 0 ? blocked.join('; ') : null,
+        // The routes come from the source, so whatever stops init placing the tag stops the manifest too.
+        manifestBlocked: blocked.length > 0 ? blocked.join('; ') : null,
+        fromBuild: false,
+        rewriting: null,
+        publishNote: null,
+        buildPublishDirs: () => [],
+        buildNotes: () => [],
         looked: [where, repoPath(ctx, pages)],
         staticDir: publicDir,
         integrate: async (tags) => (config.file ? configEdit(config.file, tags) : { manual: `${where} is missing` }),